Attempt to head off OmahaClient ANR

chrome/android/java/src/org/chromium/chrome/browser/omaha/OmahaClient.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.omaha;
 
 import android.app.AlarmManager;
 import android.app.IntentService;
 import android.app.PendingIntent;
 import android.content.Context;
@@ skipping 48 matching lines @@
     private static final String TAG = "cr.omaha";
 
     // Intent actions.
     private static final String ACTION_INITIALIZE =
             "org.chromium.chrome.browser.omaha.ACTION_INITIALIZE";
     private static final String ACTION_REGISTER_REQUEST =
             "org.chromium.chrome.browser.omaha.ACTION_REGISTER_REQUEST";
     private static final String ACTION_POST_REQUEST =
             "org.chromium.chrome.browser.omaha.ACTION_POST_REQUEST";
 
-    // Strings for extras.
-    private static final String EXTRA_FORCE_ACTION = "forceAction";
-
     // Delays between events.
     private static final long MS_PER_HOUR = 3600000;
     private static final long MS_POST_BASE_DELAY = MS_PER_HOUR;
     private static final long MS_POST_MAX_DELAY = 5 * MS_PER_HOUR;
     private static final long MS_BETWEEN_REQUESTS = 5 * MS_PER_HOUR;
     private static final int MS_CONNECTION_TIMEOUT = 60000;
 
     // Flags for retrieving the OmahaClient's state after it's written to disk.
     // The PREF_PACKAGE doesn't match the current OmahaClient package for historical reasons.
     @VisibleForTesting
@@ skipping 29 matching lines @@
 
     // Static fields
     private static boolean sEnableCommunication = true;
     private static boolean sEnableUpdateDetection = true;
     private static VersionNumberGetter sVersionNumberGetter = null;
     private static MarketURLGetter sMarketURLGetter = null;
     private static Boolean sIsFreshInstallOrDataCleared = null;
 
     // Member fields not persisted to disk.
     private boolean mStateHasBeenRestored;
-    private Context mApplicationContext;
     private ExponentialBackoffScheduler mBackoffScheduler;
     private RequestGenerator mGenerator;
 
     // State saved written to and read from disk.
     private RequestData mCurrentRequest;
     private long mTimestampOfInstall;
     private long mTimestampForNextPostAttempt;
     private long mTimestampForNewRequest;
     private String mLatestVersion;
     private String mMarketURL;
     private String mInstallSource;
     protected boolean mSendInstallEvent;
 
     public OmahaClient() {
         super(TAG);
         setIntentRedelivery(true);
     }
 
-    @Override
-    public void onCreate() {
-        super.onCreate();
-        mApplicationContext = getApplicationContext();
-        mBackoffScheduler = createBackoffScheduler(PREF_PACKAGE, mApplicationContext,
-                MS_POST_BASE_DELAY, MS_POST_MAX_DELAY);
-        mGenerator = createRequestGenerator(mApplicationContext);
-    }
-
     /**
      * Sets whether Chrome should be communicating with the Omaha server.
      * The alternative to using a static field within OmahaClient is using a member variable in
      * the ChromeTabbedActivity.  The problem is that it is difficult to set the variable before
      * ChromeTabbedActivity is started.
      */
     @VisibleForTesting
     public static void setEnableCommunication(boolean state) {
         sEnableCommunication = state;
     }
@@ skipping 11 matching lines @@
         return mTimestampForNextPostAttempt;
     }
 
     @VisibleForTesting
     long getTimestampForNewRequest() {
         return mTimestampForNewRequest;
     }
 
     @VisibleForTesting
     int getCumulativeFailedAttempts() {
-        return mBackoffScheduler.getNumFailedAttempts();
+        return getBackoffScheduler().getNumFailedAttempts();
     }
 
     /**
      * Creates the scheduler used to space out POST attempts.
      */
     @VisibleForTesting
     ExponentialBackoffScheduler createBackoffScheduler(String prefPackage, Context context,
             long base, long max) {
         return new ExponentialBackoffScheduler(prefPackage, context, base, max);
     }
 
     /**
      * Creates the request generator used to create Omaha XML.
      */
     @VisibleForTesting
     RequestGenerator createRequestGenerator(Context context) {
-        return ((ChromeApplication) getApplicationContext()).createOmahaRequestGenerator();
+        return ((ChromeApplication) context.getApplicationContext()).createOmahaRequestGenerator();
     }
 
     /**
      * Handles an action on a thread separate from the UI thread.
      * @param intent Intent fired by some part of Chrome.
      */
     @Override
     public void onHandleIntent(Intent intent) {
         assert Looper.myLooper() != Looper.getMainLooper();
 
         if (!sEnableCommunication) {
             Log.v(TAG, "Disabled.  Ignoring intent.");
             return;
         }
 
-        if (mGenerator == null) {
-            Log.e(TAG, "No request generator set.  Ignoring intent.");
-            return;
-        }
-
         if (!mStateHasBeenRestored) {
             restoreState();
         }
 
         if (ACTION_INITIALIZE.equals(intent.getAction())) {
             handleInitialize();
         } else if (ACTION_REGISTER_REQUEST.equals(intent.getAction())) {
             handleRegisterRequest(intent);
         } else if (ACTION_POST_REQUEST.equals(intent.getAction())) {
             handlePostRequestIntent(intent);
         } else {
             Log.e(TAG, "Got unknown action from intent: " + intent.getAction());
         }
     }
 
     public static Intent createInitializeIntent(Context context) {
         Intent intent = new Intent(context, OmahaClient.class);
         intent.setAction(ACTION_INITIALIZE);
         return intent;
     }
 
     /**
      * Start a recurring alarm to fire request generation intents.
      */
     private void handleInitialize() {
         scheduleRepeatingAlarm();
 
         // If a request exists, fire a POST intent to restart its timer.
-        if (hasRequest()) {
-            Intent postIntent = createPostRequestIntent(mApplicationContext, false);
-            startService(postIntent);
-        }
+        if (hasRequest()) startService(createPostRequestIntent(this));
     }
 
-    public static Intent createRegisterRequestIntent(Context context, boolean force) {
+    /**
+     * Returns an Intent for registering a new request to send to the server.
+     */
+    static Intent createRegisterRequestIntent(Context context) {
         Intent intent = new Intent(context, OmahaClient.class);
         intent.setAction(ACTION_REGISTER_REQUEST);
-        intent.putExtra(EXTRA_FORCE_ACTION, force);
         return intent;
     }
 
     /**
      * Determines if a new request should be generated.  New requests are only generated if enough
      * time has passed between now and the last time a request was generated.
      */
     private void handleRegisterRequest(Intent intent) {
-        boolean force = intent.getBooleanExtra(EXTRA_FORCE_ACTION, false);
-        if (!isChromeBeingUsed() && !force) {
+        if (!isChromeBeingUsed()) {
             cancelRepeatingAlarm();
             return;
         }
 
         // If the current request is too old, generate a new one.
-        long currentTimestamp = mBackoffScheduler.getCurrentTime();
+        long currentTimestamp = getBackoffScheduler().getCurrentTime();
         boolean isTooOld = hasRequest()
                 && mCurrentRequest.getAgeInMilliseconds(currentTimestamp) >= MS_BETWEEN_REQUESTS;
         boolean isOverdue = !hasRequest() && currentTimestamp >= mTimestampForNewRequest;
-        if (isTooOld || isOverdue || force) {
+        if (isTooOld || isOverdue) {
             registerNewRequest(currentTimestamp);
         }
 
-        // Create an intent to send the request.  If we're forcing a registration, force the POST,
-        // as well.
+        // Create an intent to send the request.
         if (hasRequest()) {
-            Intent postIntent = createPostRequestIntent(mApplicationContext, force);
-            startService(postIntent);
+            startService(createPostRequestIntent(this));
         }
     }
 
-    public static Intent createPostRequestIntent(Context context, boolean force) {
+    /**
+     * Returns an Intent for POSTing the current request to the Omaha server.
+     */
+    static Intent createPostRequestIntent(Context context) {
         Intent intent = new Intent(context, OmahaClient.class);
         intent.setAction(ACTION_POST_REQUEST);
-        intent.putExtra(EXTRA_FORCE_ACTION, force);
         return intent;
     }
 
     /**
      * Sends the request it is holding.
      */
     @VisibleForTesting
     private void handlePostRequestIntent(Intent intent) {
         if (!hasRequest()) {
             return;
         }
 
-        boolean force = intent.getBooleanExtra(EXTRA_FORCE_ACTION, false);
-
         // If enough time has passed since the last attempt, try sending a request.
-        long currentTimestamp = mBackoffScheduler.getCurrentTime();
-        if (currentTimestamp >= mTimestampForNextPostAttempt || force) {
+        long currentTimestamp = getBackoffScheduler().getCurrentTime();
+        if (currentTimestamp >= mTimestampForNextPostAttempt) {
             // All requests made during the same session should have the same ID.
             String sessionID = generateRandomUUID();
             boolean sendingInstallRequest = mSendInstallEvent;
             boolean succeeded = generateAndPostRequest(currentTimestamp, sessionID);
 
             if (succeeded && sendingInstallRequest) {
                 // Only the first request ever generated should contain an install event.
                 mSendInstallEvent = false;
 
                 // Create and immediately send another request for a ping and update check.
                 registerNewRequest(currentTimestamp);
-                succeeded = generateAndPostRequest(currentTimestamp, sessionID);
-            }
-
-            if (force) {
-                if (succeeded) {
-                    Log.v(TAG, "Requests successfully sent to Omaha server.");
-                } else {
-                    Log.e(TAG, "Requests failed to reach Omaha server.");
-                }
+                generateAndPostRequest(currentTimestamp, sessionID);

[nyquist, 2015/09/01 22:32:50]

So this ignores the return value of the function now. Does it still need to be a
boolean?

[gone, 2015/09/01 22:36:12]

There's a call right above this where the boolean return value is actually used;
it's now only used for the case where we can chain the install and the ping
event instead of also for outputting log messages.

             }
         } else {
             // Set an alarm to POST at the proper time.  Previous alarms are destroyed.
-            Intent postIntent = createPostRequestIntent(mApplicationContext, false);
-            mBackoffScheduler.createAlarm(postIntent, mTimestampForNextPostAttempt);
+            Intent postIntent = createPostRequestIntent(this);
+            getBackoffScheduler().createAlarm(postIntent, mTimestampForNextPostAttempt);
         }
 
         // Write everything back out again to save our state.
         saveState();
     }
 
     private boolean generateAndPostRequest(long currentTimestamp, String sessionID) {
+        ExponentialBackoffScheduler scheduler = getBackoffScheduler();
         try {
             // Generate the XML for the current request.
             long installAgeInDays = RequestGenerator.installAge(currentTimestamp,
                     mTimestampOfInstall, mCurrentRequest.isSendInstallEvent());
-            String version = getVersionNumberGetter().getCurrentlyUsedVersion(mApplicationContext);
-            String xml =
-                    mGenerator.generateXML(sessionID, version, installAgeInDays, mCurrentRequest);
+            String version = getVersionNumberGetter().getCurrentlyUsedVersion(this);
+            String xml = getRequestGenerator().generateXML(
+                    sessionID, version, installAgeInDays, mCurrentRequest);
 
             // Send the request to the server & wait for a response.
             String response = postRequest(currentTimestamp, xml);
             parseServerResponse(response);
 
             // If we've gotten this far, we've successfully sent a request.
             mCurrentRequest = null;
             mTimestampForNextPostAttempt = currentTimestamp + MS_POST_BASE_DELAY;
-            mBackoffScheduler.resetFailedAttempts();
+            scheduler.resetFailedAttempts();
             Log.i(TAG, "Request to Server Successful. Timestamp for next request:"
                     + String.valueOf(mTimestampForNextPostAttempt));
 
             return true;
         } catch (RequestFailureException e) {
             // Set the alarm to try again later.
             Log.e(TAG, "Failed to contact server: ", e);
-            Intent postIntent = createPostRequestIntent(mApplicationContext, false);
-            mTimestampForNextPostAttempt = mBackoffScheduler.createAlarm(postIntent);
-            mBackoffScheduler.increaseFailedAttempts();
+            Intent postIntent = createPostRequestIntent(this);
+            mTimestampForNextPostAttempt = scheduler.createAlarm(postIntent);
+            scheduler.increaseFailedAttempts();
             return false;
         }
     }
 
     /**
      * Sets a repeating alarm that fires request registration Intents.
      * Setting the alarm overwrites whatever alarm is already there, and rebooting
      * clears whatever alarms are currently set.
      */
     private void scheduleRepeatingAlarm() {
-        Intent registerIntent = createRegisterRequestIntent(mApplicationContext, false);
-        PendingIntent pIntent =
-                PendingIntent.getService(mApplicationContext, 0, registerIntent, 0);
-        AlarmManager am =
-                (AlarmManager) mApplicationContext.getSystemService(Context.ALARM_SERVICE);
+        Intent registerIntent = createRegisterRequestIntent(this);
+        PendingIntent pIntent = PendingIntent.getService(this, 0, registerIntent, 0);
+        AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
         setAlarm(am, pIntent, AlarmManager.RTC, mTimestampForNewRequest);
     }
 
     /**
      * Sets up a timer to fire after each interval.
      * Override to prevent a real alarm from being set.
      */
     @VisibleForTesting
     protected void setAlarm(AlarmManager am, PendingIntent operation, int alarmType,
             long triggerAtTime) {
         try {
             am.setRepeating(AlarmManager.RTC, triggerAtTime, MS_BETWEEN_REQUESTS, operation);
         } catch (SecurityException e) {
             Log.e(TAG, "Failed to set repeating alarm.");
         }
     }
 
     /**
      * Cancels the alarm that launches this service.  It will be replaced when Chrome next resumes.
      */
     private void cancelRepeatingAlarm() {
-        Intent requestIntent = createRegisterRequestIntent(mApplicationContext, false);
-        PendingIntent pendingIntent = PendingIntent.getService(mApplicationContext, 0,
-                requestIntent, PendingIntent.FLAG_NO_CREATE);
+        Intent requestIntent = createRegisterRequestIntent(this);
+        PendingIntent pendingIntent =
+                PendingIntent.getService(this, 0, requestIntent, PendingIntent.FLAG_NO_CREATE);
         // Setting FLAG_NO_CREATE forces Android to return an already existing PendingIntent.
         // Here it would be the one that was used to create the existing alarm (if it exists).
         // If the pendingIntent is null, it is likely that no alarm was created.
         if (pendingIntent != null) {
-            AlarmManager am =
-                    (AlarmManager) mApplicationContext.getSystemService(Context.ALARM_SERVICE);
+            AlarmManager am = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
             am.cancel(pendingIntent);
             pendingIntent.cancel();
         }
     }
 
     /**
      * Determine whether or not Chrome is currently being used actively.
      */
     @VisibleForTesting
     protected boolean isChromeBeingUsed() {
         boolean isChromeVisible = ApplicationStatus.hasVisibleActivities();
-        boolean isScreenOn = ApiCompatibilityUtils.isInteractive(mApplicationContext);
+        boolean isScreenOn = ApiCompatibilityUtils.isInteractive(this);
         return isChromeVisible && isScreenOn;
     }
 
     /**
      * Registers a new request with the current timestamp.  Internal timestamps are reset to start
      * fresh.
      * @param currentTimestamp Current time.
      */
     @VisibleForTesting
     void registerNewRequest(long currentTimestamp) {
         mCurrentRequest = createRequestData(currentTimestamp, null);
-        mBackoffScheduler.resetFailedAttempts();
+        getBackoffScheduler().resetFailedAttempts();
         mTimestampForNextPostAttempt = currentTimestamp;
 
         // Tentatively set the timestamp for a new request.  This will be updated when the server
         // is successfully contacted.
         mTimestampForNewRequest = currentTimestamp + MS_BETWEEN_REQUESTS;
         scheduleRepeatingAlarm();
 
         saveState();
     }
 
@@ skipping 34 matching lines @@
             }
         }
 
         return response;
     }
 
     /**
      * Parse the server's response and confirm that we received an OK response.
      */
     private void parseServerResponse(String response) throws RequestFailureException {
-        String appId = mGenerator.getAppId();
+        String appId = getRequestGenerator().getAppId();
         boolean sentPingAndUpdate = !mSendInstallEvent;
         ResponseParser parser =
                 new ResponseParser(appId, mSendInstallEvent, sentPingAndUpdate, sentPingAndUpdate);
         parser.parseResponse(response);
-        mTimestampForNewRequest = mBackoffScheduler.getCurrentTime() + MS_BETWEEN_REQUESTS;
+        mTimestampForNewRequest = getBackoffScheduler().getCurrentTime() + MS_BETWEEN_REQUESTS;
         mLatestVersion = parser.getNewVersion();
         mMarketURL = parser.getURL();
         scheduleRepeatingAlarm();
     }
 
     /**
      * Returns a HttpURLConnection to the server.
      */
     @VisibleForTesting
     protected HttpURLConnection createConnection() throws RequestFailureException {
         try {
-            URL url = new URL(mGenerator.getServerUrl());
+            URL url = new URL(getRequestGenerator().getServerUrl());
             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
             connection.setConnectTimeout(MS_CONNECTION_TIMEOUT);
             connection.setReadTimeout(MS_CONNECTION_TIMEOUT);
             return connection;
         } catch (MalformedURLException e) {
             throw new RequestFailureException("Caught a malformed URL exception.", e);
         } catch (IOException e) {
             throw new RequestFailureException("Failed to open connection to URL", e);
         }
     }
@@ skipping 74 matching lines @@
         }
     }
 
     /**
      * Checks if we know about a newer version available than the one we're using.  This does not
      * actually fire any requests over to the server; it just checks the version we stored the last
      * time we talked to the Omaha server.
      *
      * NOTE: This function incurs I/O, so don't use it on the main thread.
      */
-    public static boolean isNewerVersionAvailable(Context applicationContext) {
+    static boolean isNewerVersionAvailable(Context context) {
         assert Looper.myLooper() != Looper.getMainLooper();
 
         // This may be explicitly enabled for some channels and for unit tests.
         if (!sEnableUpdateDetection) {
             return false;
         }
 
         // If the market link is bad, don't show an update to avoid frustrating users trying to
         // hit the "Update" button.
-        if ("".equals(getMarketURL(applicationContext))) {
+        if ("".equals(getMarketURL(context))) {
             return false;
         }
 
         // Compare version numbers.
         VersionNumberGetter getter = getVersionNumberGetter();
-        String currentStr = getter.getCurrentlyUsedVersion(applicationContext);
-        String latestStr =
-                getter.getLatestKnownVersion(applicationContext, PREF_PACKAGE, PREF_LATEST_VERSION);
+        String currentStr = getter.getCurrentlyUsedVersion(context);
+        String latestStr = getter.getLatestKnownVersion(context, PREF_PACKAGE, PREF_LATEST_VERSION);
 
         VersionNumber currentVersionNumber = VersionNumber.fromString(currentStr);
         VersionNumber latestVersionNumber = VersionNumber.fromString(latestStr);
 
         if (currentVersionNumber == null || latestVersionNumber == null) {
             return false;
         }
 
         return currentVersionNumber.isSmallerThan(latestVersionNumber);
     }
 
     /**
      * Determine how the Chrome APK arrived on the device.
      * @param context Context to pull resources from.
      * @return A String indicating the install source.
      */
-    String determineInstallSource(Context context) {
+    String determineInstallSource() {
         boolean isInSystemImage = (getApplicationFlags() & ApplicationInfo.FLAG_SYSTEM) != 0;
         return isInSystemImage ? INSTALL_SOURCE_SYSTEM : INSTALL_SOURCE_ORGANIC;
     }
 
     /**
      * Returns the Application's flags, used to determine if Chrome was installed as part of the
      * system image.
      * @return The Application's flags.
      */
     @VisibleForTesting
-    public int getApplicationFlags() {
-        return mApplicationContext.getApplicationInfo().flags;
+    int getApplicationFlags() {
+        return getApplicationInfo().flags;
     }
 
     /**
      * Reads the data back from the file it was saved to.  Uses SharedPreferences to handle I/O.
      * Sanity checks are performed on the timestamps to guard against clock changing.
      */
     @VisibleForTesting
     void restoreState() {
         boolean mustRewriteState = false;
-        SharedPreferences preferences =
-                mApplicationContext.getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
+        SharedPreferences preferences = getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
         Map<String, ?> items = preferences.getAll();
 
         // Read out the recorded data.
-        long currentTime = mBackoffScheduler.getCurrentTime();
+        long currentTime = getBackoffScheduler().getCurrentTime();
         mTimestampForNewRequest =
                 getLongFromMap(items, PREF_TIMESTAMP_FOR_NEW_REQUEST, currentTime);
         mTimestampForNextPostAttempt =
                 getLongFromMap(items, PREF_TIMESTAMP_FOR_NEXT_POST_ATTEMPT, currentTime);
 
         long requestTimestamp = getLongFromMap(items, PREF_TIMESTAMP_OF_REQUEST, INVALID_TIMESTAMP);
 
         // If the preference doesn't exist, it's likely that we haven't sent an install event.
         mSendInstallEvent = getBooleanFromMap(items, PREF_SEND_INSTALL_EVENT, true);
 
         // Restore the install source.
-        String defaultInstallSource = determineInstallSource(mApplicationContext);
+        String defaultInstallSource = determineInstallSource();
         mInstallSource = getStringFromMap(items, PREF_INSTALL_SOURCE, defaultInstallSource);
 
         // If we're not sending an install event, don't bother restoring the request ID:
         // the server does not expect to have persisted request IDs for pings or update checks.
         String persistedRequestId = mSendInstallEvent
                 ? getStringFromMap(items, PREF_PERSISTED_REQUEST_ID, INVALID_REQUEST_ID)
                 : INVALID_REQUEST_ID;
 
         mCurrentRequest = requestTimestamp == INVALID_TIMESTAMP
                 ? null : createRequestData(requestTimestamp, persistedRequestId);
 
         mLatestVersion = getStringFromMap(items, PREF_LATEST_VERSION, "");
         mMarketURL = getStringFromMap(items, PREF_MARKET_URL, "");
 
         // If we don't have a timestamp for when we installed Chrome, then set it to now.
         mTimestampOfInstall = getLongFromMap(items, PREF_TIMESTAMP_OF_INSTALL, currentTime);
 
         // Confirm that the timestamp for the next request is less than the base delay.
         long delayToNewRequest = mTimestampForNewRequest - currentTime;
         if (delayToNewRequest > MS_BETWEEN_REQUESTS) {
             Log.w(TAG, "Delay to next request (" + delayToNewRequest
                     + ") is longer than expected.  Resetting to now.");
             mTimestampForNewRequest = currentTime;
             mustRewriteState = true;
         }
 
         // Confirm that the timestamp for the next POST is less than the current delay.
         long delayToNextPost = mTimestampForNextPostAttempt - currentTime;
-        if (delayToNextPost > mBackoffScheduler.getGeneratedDelay()) {
+        if (delayToNextPost > getBackoffScheduler().getGeneratedDelay()) {
             Log.w(TAG, "Delay to next post attempt (" + delayToNextPost
-                    + ") is greater than expected (" + mBackoffScheduler.getGeneratedDelay()
+                    + ") is greater than expected (" + getBackoffScheduler().getGeneratedDelay()
                     + ").  Resetting to now.");
             mTimestampForNextPostAttempt = currentTime;
             mustRewriteState = true;
         }
 
         if (mustRewriteState) {
             saveState();
         }
 
         mStateHasBeenRestored = true;
     }
 
     /**
      * Writes out the current state to a file.
      */
     private void saveState() {
-        SharedPreferences prefs =
-                mApplicationContext.getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
+        SharedPreferences prefs = getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = prefs.edit();
         editor.putBoolean(PREF_SEND_INSTALL_EVENT, mSendInstallEvent);
-        setIsFreshInstallOrDataHasBeenCleared(mApplicationContext);
+        setIsFreshInstallOrDataHasBeenCleared(this);
         editor.putLong(PREF_TIMESTAMP_OF_INSTALL, mTimestampOfInstall);
         editor.putLong(PREF_TIMESTAMP_FOR_NEXT_POST_ATTEMPT, mTimestampForNextPostAttempt);
         editor.putLong(PREF_TIMESTAMP_FOR_NEW_REQUEST, mTimestampForNewRequest);
         editor.putLong(PREF_TIMESTAMP_OF_REQUEST,
                 hasRequest() ? mCurrentRequest.getCreationTimestamp() : INVALID_TIMESTAMP);
         editor.putString(PREF_PERSISTED_REQUEST_ID,
                 hasRequest() ? mCurrentRequest.getRequestID() : INVALID_REQUEST_ID);
         editor.putString(PREF_LATEST_VERSION, mLatestVersion == null ? "" : mLatestVersion);
         editor.putString(PREF_MARKET_URL, mMarketURL == null ? "" : mMarketURL);
 
@@ skipping 73 matching lines @@
         Boolean value = (Boolean) items.get(key);
         return value != null ? value : defaultValue;
     }
 
     /**
      * @return Whether it is either a fresh install or data has been cleared.
      * PREF_TIMESTAMP_OF_INSTALL is set within the first few seconds after a fresh install.
      * sIsFreshInstallOrDataCleared will be set to true if PREF_TIMESTAMP_OF_INSTALL has not
      * been previously set. Else, it will be set to false. sIsFreshInstallOrDataCleared is
      * guarded by sLock.
-     * @param applicationContext The current application Context.
+     * @param context The current Context.
      */
-    public static boolean isFreshInstallOrDataHasBeenCleared(Context applicationContext) {
-        return setIsFreshInstallOrDataHasBeenCleared(applicationContext);
+    public static boolean isFreshInstallOrDataHasBeenCleared(Context context) {
+        return setIsFreshInstallOrDataHasBeenCleared(context);
     }
 
-    private static boolean setIsFreshInstallOrDataHasBeenCleared(Context applicationContext) {
+    private static boolean setIsFreshInstallOrDataHasBeenCleared(Context context) {
         synchronized (sIsFreshInstallLock) {
             if (sIsFreshInstallOrDataCleared == null) {
-                SharedPreferences prefs = applicationContext.getSharedPreferences(
+                SharedPreferences prefs = context.getSharedPreferences(
                         PREF_PACKAGE, Context.MODE_PRIVATE);
                 sIsFreshInstallOrDataCleared = (prefs.getLong(PREF_TIMESTAMP_OF_INSTALL, -1) == -1);
             }
             return sIsFreshInstallOrDataCleared;
         }
     }
+
+    protected final RequestGenerator getRequestGenerator() {
+        if (mGenerator == null) mGenerator = createRequestGenerator(this);
+        return mGenerator;
+    }
+
+    protected final ExponentialBackoffScheduler getBackoffScheduler() {
+        if (mBackoffScheduler == null) {
+            mBackoffScheduler = createBackoffScheduler(
+                    PREF_PACKAGE, this, MS_POST_BASE_DELAY, MS_POST_MAX_DELAY);
+        }
+        return mBackoffScheduler;
+    }
 }