Remove use of locks (5/n)

    private static final long DEFAULT_ROLLBACK_LIFETIME_DURATION_MILLIS =

            TimeUnit.DAYS.toMillis(14);

    // Lock used to synchronize accesses to in-memory rollback data

    // structures. By convention, methods with the suffix "Locked" require

    // mLock is held when they are called.

    private final Object mLock = new Object();

    // No need for guarding with lock because value is only accessed in handler thread

    // and the value will be written on boot complete. Initialization here happens before

    // handler threads are running so that's fine.

    // Accessed on the handler thread only.

    private long mRollbackLifetimeDurationInMillis = DEFAULT_ROLLBACK_LIFETIME_DURATION_MILLIS;

    private static final long HANDLER_THREAD_TIMEOUT_DURATION_MILLIS =

            TimeUnit.MINUTES.toMillis(10);

    // Used for generating rollback IDs.

    // Accessed on the handler thread only.

    private final Random mRandom = new SecureRandom();

    // Set of allocated rollback ids

    @GuardedBy("mLock")

    // Set of allocated rollback ids.

    // Accessed on the handler thread only.

    private final SparseBooleanArray mAllocatedRollbackIds = new SparseBooleanArray();

    // The list of all rollbacks, including available and committed rollbacks.

    @GuardedBy("mLock")

    // Accessed on the handler thread only.

    private final List<Rollback> mRollbacks;

    // Apk sessions from a staged session with no matching rollback.

    @GuardedBy("mLock")

    // Accessed on the handler thread only.

    private final IntArray mOrphanedApkSessionIds = new IntArray();

    private final RollbackStore mRollbackStore;

    // This field stores the difference in Millis between the uptime (millis since device

    // has booted) and current time (device wall clock) - it's used to update rollback

    // timestamps when the time is changed, by the user or by change of timezone.

    // No need for guarding with lock because value is only accessed in handler thread.

    // Accessed on the handler thread only.

    private long  mRelativeBootTime = calculateRelativeBootTime();

    RollbackManagerServiceImpl(Context context) {

        mAppDataRollbackHelper = new AppDataRollbackHelper(mInstaller);

        // Load rollback data from device storage.

        synchronized (mLock) {

        mRollbacks = mRollbackStore.loadRollbacks();

        if (!context.getPackageManager().isDeviceUpgrading()) {

            for (Rollback rollback : mRollbacks) {

            }

            mRollbacks.clear();

        }

        }

        // Kick off and start monitoring the handler thread.

        mHandlerThread = new HandlerThread("RollbackManagerServiceHandler");

                    if (LOCAL_LOGV) {

                        Slog.v(TAG, "broadcast=ACTION_CANCEL_ENABLE_ROLLBACK id=" + sessionId);

                    }

                    synchronized (mLock) {

                    Rollback rollback = getRollbackForSessionLocked(sessionId);

                    if (rollback != null && rollback.isEnabling()) {

                        mRollbacks.remove(rollback);

                    }

                }

            }

            }

        }, enableRollbackTimedOutFilter, null, getHandler());

        IntentFilter userAddedIntentFilter = new IntentFilter(Intent.ACTION_USER_ADDED);

        enforceManageRollbacks("getAvailableRollbacks");

        return awaitResult(() -> {

            assertInWorkerThread();

            synchronized (mLock) {

            List<RollbackInfo> rollbacks = new ArrayList<>();

            for (int i = 0; i < mRollbacks.size(); ++i) {

                Rollback rollback = mRollbacks.get(i);

                }

            }

            return new ParceledListSlice<>(rollbacks);

            }

        });

    }

        return awaitResult(() -> {

            assertInWorkerThread();

            synchronized (mLock) {

            List<RollbackInfo> rollbacks = new ArrayList<>();

            for (int i = 0; i < mRollbacks.size(); ++i) {

                Rollback rollback = mRollbacks.get(i);

                }

            }

            return new ParceledListSlice<>(rollbacks);

            }

        });

    }

                mRelativeBootTime = calculateRelativeBootTime();

                final long timeDifference = mRelativeBootTime - oldRelativeBootTime;

                synchronized (mLock) {

                Iterator<Rollback> iter = mRollbacks.iterator();

                while (iter.hasNext()) {

                    Rollback rollback = iter.next();

                            rollback.getTimestamp().plusMillis(timeDifference));

                }

            }

            }

        };

        final IntentFilter filter = new IntentFilter();

        filter.addAction(Intent.ACTION_TIME_CHANGED);

        awaitResult(() -> {

            assertInWorkerThread();

            synchronized (mLock) {

            mRollbacks.clear();

            mRollbacks.addAll(mRollbackStore.loadRollbacks());

            }

        });

    }

    @WorkerThread

    private void expireRollbackForPackageInternal(String packageName) {

        assertInWorkerThread();

        synchronized (mLock) {

        Iterator<Rollback> iter = mRollbacks.iterator();

        while (iter.hasNext()) {

            Rollback rollback = iter.next();

            }

        }

    }

    }

    @ExtThread

    @Override

        awaitResult(() -> {

            assertInWorkerThread();

            final List<Rollback> rollbacks;

            synchronized (mLock) {

            rollbacks = new ArrayList<>(mRollbacks);

            }

            for (int i = 0; i < rollbacks.size(); i++) {

                Rollback rollback = rollbacks.get(i);

            List<Rollback> enabling = new ArrayList<>();

            List<Rollback> restoreInProgress = new ArrayList<>();

            Set<String> apexPackageNames = new HashSet<>();

            synchronized (mLock) {

            Iterator<Rollback> iter = mRollbacks.iterator();

            while (iter.hasNext()) {

                Rollback rollback = iter.next();

                }

                apexPackageNames.addAll(rollback.getApexPackageNames());

            }

            }

            for (Rollback rollback : enabling) {

                makeRollbackAvailable(rollback);

                onPackageReplaced(apexPackageName);

            }

            synchronized (mLock) {

            mOrphanedApkSessionIds.clear();

            }

            mPackageHealthObserver.onBootCompletedAsync();

        });

        // package that is about to be installed?

        long installedVersion = getInstalledPackageVersion(packageName);

        synchronized (mLock) {

        Iterator<Rollback> iter = mRollbacks.iterator();

        while (iter.hasNext()) {

            Rollback rollback = iter.next();

            }

        }

    }

    }

    /**

     * Called when a package has been completely removed from the device.

        assertInWorkerThread();

        Instant now = Instant.now();

        Instant oldest = null;

        synchronized (mLock) {

        Iterator<Rollback> iter = mRollbacks.iterator();

        while (iter.hasNext()) {

            Rollback rollback = iter.next();

                oldest = rollbackTimestamp;

            }

        }

        }

        if (oldest != null) {

            scheduleExpiration(now.until(oldest.plusMillis(mRollbackLifetimeDurationInMillis),

        // Check to see if this is the apk session for a staged session with

        // rollback enabled.

        synchronized (mLock) {

        for (int i = 0; i < mRollbacks.size(); ++i) {

            Rollback rollback = mRollbacks.get(i);

            if (rollback.getApkSessionId() == parentSession.getSessionId()) {

                return true;

            }

        }

        }

        // Check to see if this is the apk session for a staged session for which rollback was

        // cancelled.

        synchronized (mLock) {

        if (mOrphanedApkSessionIds.indexOf(parentSession.getSessionId()) != -1) {

            Slog.w(TAG, "Not enabling rollback for apk as no matching staged session "

                    + "rollback exists");

            return false;

        }

        }

        Rollback newRollback;

        synchronized (mLock) {

        // See if we already have a Rollback that contains this package

        // session. If not, create a new Rollback for the parent session

        // that we will use for all the packages in the session.

        if (newRollback == null) {

            newRollback = createNewRollbackLocked(parentSession);

        }

        }

        return enableRollbackForPackageSession(newRollback, packageSession);

    }

            Slog.v(TAG, "snapshotUserData pkg=" + packageName

                    + " users=" + Arrays.toString(userIds));

        }

        synchronized (mLock) {

        for (int i = 0; i < mRollbacks.size(); i++) {

            Rollback rollback = mRollbacks.get(i);

            rollback.snapshotUserData(packageName, userIds, mAppDataRollbackHelper);

        }

    }

    }

    @WorkerThread

    private void restoreUserDataInternal(

            Slog.v(TAG, "restoreUserData pkg=" + packageName

                    + " users=" + Arrays.toString(userIds));

        }

        synchronized (mLock) {

        for (int i = 0; i < mRollbacks.size(); ++i) {

            Rollback rollback = mRollbacks.get(i);

            if (rollback.restoreUserDataForPackageIfInProgress(

            }

        }

    }

    }

    @ExtThread

    @Override

            }

            Rollback newRollback;

            synchronized (mLock) {

            newRollback = createNewRollbackLocked(session);

            }

            if (!session.isMultiPackage()) {

                if (!enableRollbackForPackageSession(newRollback, session)) {

        getHandler().post(() -> {

            assertInWorkerThread();

            Rollback rollback = null;

            synchronized (mLock) {

            for (int i = 0; i < mRollbacks.size(); ++i) {

                Rollback candidate = mRollbacks.get(i);

                if (candidate.getStagedSessionId() == originalSessionId) {

                        + ". Adding orphaned apk session " + apkSessionId);

                mOrphanedApkSessionIds.add(apkSessionId);

            }

            }

            if (rollback != null) {

                rollback.setApkSessionId(apkSessionId);

            if (success) {

                Rollback rollback;

                synchronized (mLock) {

                rollback = getRollbackForSessionLocked(sessionId);

                }

                if (rollback != null && !rollback.isStaged() && rollback.isEnabling()

                        && rollback.notifySessionWithSuccess()

                        && completeEnableRollback(rollback)) {

                    makeRollbackAvailable(rollback);

                }

            } else {

                synchronized (mLock) {

                Rollback rollback = getRollbackForSessionLocked(sessionId);

                if (rollback != null && rollback.isEnabling()) {

                    Slog.w(TAG, "Delete rollback id=" + rollback.info.getRollbackId()

            }

        }

    }

    }

    /**

     * Persist a rollback as enable-completed. It does not make the rollback available yet.

    @WorkerThread

    private Rollback getRollbackForId(int rollbackId) {

        assertInWorkerThread();

        synchronized (mLock) {

        for (int i = 0; i < mRollbacks.size(); ++i) {

            Rollback rollback = mRollbacks.get(i);

            if (rollback.info.getRollbackId() == rollbackId) {

                return rollback;

            }

        }

        }

        return null;

    }

    @WorkerThread

    @GuardedBy("mLock")

    private int allocateRollbackIdLocked() {

        assertInWorkerThread();

        int n = 0;

        IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "  ");

        awaitResult(() -> {

            assertInWorkerThread();

            synchronized (mLock) {

            for (Rollback rollback : mRollbacks) {

                rollback.dump(ipw);

            }

            ipw.println();

            PackageWatchdog.getInstance(mContext).dump(ipw);

            }

        });

    }

     * and adds it to {@link #mRollbacks}.

     */

    @WorkerThread

    @GuardedBy("mLock")

    private Rollback createNewRollbackLocked(PackageInstaller.SessionInfo parentSession) {

        assertInWorkerThread();

        int rollbackId = allocateRollbackIdLocked();

     * Returns null if not found.

     */

    @WorkerThread

    @GuardedBy("mLock")

    @Nullable

    private Rollback getRollbackForSessionLocked(int sessionId) {

        assertInWorkerThread();