Attempt Manager Refactor and Opt-In Pipeline Refactor

chrome/browser/resources/google_now/background.js

 // Copyright (c) 2013 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.
 
 'use strict';
 
 /**
  * @fileoverview The event page for Google Now for Chrome implementation.
  * The Google Now event page gets Google Now cards from the server and shows
  * them as Chrome notifications.
@@ skipping 36 matching lines @@
 /**
  * Maximal period for polling for Google Now Notifications cards to use when the
  * period from the server is not available.
  */
 var MAXIMUM_POLLING_PERIOD_SECONDS = 60 * 60;  // 1 hour
 
 /**
  * Initial period for polling for Google Now optin notification after push
  * messaging indicates Google Now is enabled.
  */
-var INITIAL_OPTIN_POLLING_PERIOD_SECONDS = 60;  // 1 minute
+var INITIAL_OPTIN_RECHECK_PERIOD_SECONDS = 60;  // 1 minute
 
 /**
  * Maximum period for polling for Google Now optin notification after push
  * messaging indicates Google Now is enabled. It is expected that the alarm
  * will be stopped after this.
  */
-var MAXIMUM_OPTIN_POLLING_PERIOD_SECONDS = 16 * 60;  // 16 minutes
+var MAXIMUM_OPTIN_RECHECK_PERIOD_SECONDS = 16 * 60;  // 16 minutes
 
 /**
  * Initial period for retrying the server request for dismissing cards.
  */
 var INITIAL_RETRY_DISMISS_PERIOD_SECONDS = 60;  // 1 minute
 
 /**
  * Maximum period for retrying the server request for dismissing cards.
  */
 var MAXIMUM_RETRY_DISMISS_PERIOD_SECONDS = 60 * 60;  // 1 hour
@@ skipping 123 matching lines @@
 wrapper.instrumentChromeApiFunction(
     'notifications.onButtonClicked.addListener', 0);
 wrapper.instrumentChromeApiFunction('notifications.onClicked.addListener', 0);
 wrapper.instrumentChromeApiFunction('notifications.onClosed.addListener', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onPermissionLevelChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onShowSettings.addListener', 0);
 wrapper.instrumentChromeApiFunction('permissions.contains', 1);
 wrapper.instrumentChromeApiFunction('pushMessaging.onMessage.addListener', 0);
+wrapper.instrumentChromeApiFunction('storage.onChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction('runtime.onInstalled.addListener', 0);
 wrapper.instrumentChromeApiFunction('runtime.onStartup.addListener', 0);
 wrapper.instrumentChromeApiFunction('tabs.create', 1);
 
 var updateCardsAttempts = buildAttemptManager(
     'cards-update',
     requestCards,
     INITIAL_POLLING_PERIOD_SECONDS,
     MAXIMUM_POLLING_PERIOD_SECONDS);
-var optInCheckAttempts = buildAttemptManager(
+var optInPollAttempts = buildAttemptManager(
     'optin',
-    pollOptedIn,
-    INITIAL_OPTIN_POLLING_PERIOD_SECONDS,
-    MAXIMUM_OPTIN_POLLING_PERIOD_SECONDS);
+    pollOptedInNoImmediateRecheck,
+    INITIAL_POLLING_PERIOD_SECONDS,
+    MAXIMUM_POLLING_PERIOD_SECONDS);
+var optInRecheckAttempts = buildAttemptManager(
+    'optin-recheck',
+    pollOptedInWithRecheck,
+    INITIAL_OPTIN_RECHECK_PERIOD_SECONDS,
+    MAXIMUM_OPTIN_RECHECK_PERIOD_SECONDS);
 var dismissalAttempts = buildAttemptManager(
     'dismiss',
     retryPendingDismissals,
     INITIAL_RETRY_DISMISS_PERIOD_SECONDS,
     MAXIMUM_RETRY_DISMISS_PERIOD_SECONDS);
 var cardSet = buildCardSet();
 
 var authenticationManager = buildAuthenticationManager();
 
 /**
@@ skipping 186 matching lines @@
     };
 
     var combinedCard =
         combinedCards[receivedNotification.chromeNotificationId] || [];
     combinedCard.push(uncombinedNotification);
     combinedCards[receivedNotification.chromeNotificationId] = combinedCard;
   }
 }
 
 /**
+ * Calculates the soonest poll time from a map of groups as an absolute time.
+ * @param {Object.<string, StoredNotificationGroup>} groups Map from group name
+ *     to group information.
+ * @return {number} The next poll time based off of the groups.
+ */
+function calculateNextPollTimeMilliseconds(groups) {
+  var nextPollTime = null;
+
+  for (var groupName in groups) {
+    var group = groups[groupName];
+    if (group.nextPollTime !== undefined) {
+      nextPollTime = nextPollTime == null ?
+          group.nextPollTime : Math.min(group.nextPollTime, nextPollTime);
+    }
+  }
+
+  // At least one of the groups must have nextPollTime.
+  verify(nextPollTime != null, 'calculateNextPollTime: nextPollTime is null');
+  return nextPollTime;
+}
+
+/**
  * Schedules next cards poll.
  * @param {Object.<string, StoredNotificationGroup>} groups Map from group name
  *     to group information.
- * @param {boolean} isOptedIn True if the user is opted in to Google Now.
  */
-function scheduleNextPoll(groups, isOptedIn) {
-  if (isOptedIn) {
-    var nextPollTime = null;
+function scheduleNextCardsPoll(groups) {
+  var nextPollTimeMs = calculateNextPollTimeMilliseconds(groups);
 
-    for (var groupName in groups) {
-      var group = groups[groupName];
-      if (group.nextPollTime !== undefined) {
-        nextPollTime = nextPollTime == null ?
-            group.nextPollTime : Math.min(group.nextPollTime, nextPollTime);
-      }
-    }
-
-    // At least one of the groups must have nextPollTime.
-    verify(nextPollTime != null, 'scheduleNextPoll: nextPollTime is null');
-
-    var nextPollDelaySeconds = Math.max(
-        (nextPollTime - Date.now()) / MS_IN_SECOND,
-        MINIMUM_POLLING_PERIOD_SECONDS);
-    updateCardsAttempts.start(nextPollDelaySeconds);
-  } else {
-    instrumented.metricsPrivate.getVariationParams(
-        'GoogleNow', function(params) {
-      var optinPollPeriodSeconds =
-          parseInt(params && params.optinPollPeriodSeconds, 10) ||
-          DEFAULT_OPTIN_CHECK_PERIOD_SECONDS;
-      updateCardsAttempts.start(optinPollPeriodSeconds);
-    });
-  }
+  var nextPollDelaySeconds = Math.max(
+      (nextPollTimeMs - Date.now()) / MS_IN_SECOND,
+      MINIMUM_POLLING_PERIOD_SECONDS);
+  updateCardsAttempts.start(nextPollDelaySeconds);
 }
 
 /**
+ * Schedules the next opt-in check poll.
+ */
+function scheduleOptInCheckPoll() {
+  instrumented.metricsPrivate.getVariationParams(
+      'GoogleNow', function(params) {
+    var optinPollPeriodSeconds =
+        parseInt(params && params.optinPollPeriodSeconds, 10) ||
+        DEFAULT_OPTIN_CHECK_PERIOD_SECONDS;
+    optInPollAttempts.start(optinPollPeriodSeconds);
+  });
+}
+
+/**
  * Combines notification groups into a set of Chrome notifications.
  * @param {Object.<string, StoredNotificationGroup>} notificationGroups Map from
  *     group name to group information.
  * @return {Object.<ChromeNotificationId, CombinedCard>} Cards to show.
  */
 function combineCardsFromGroups(notificationGroups) {
   console.log('combineCardsFromGroups ' + JSON.stringify(notificationGroups));
   /** @type {Object.<ChromeNotificationId, CombinedCard>} */
   var combinedCards = {};
 
   for (var groupName in notificationGroups)
     combineGroup(combinedCards, notificationGroups[groupName]);
 
   return combinedCards;
 }
 
 /**
  * Processes a server response for consumption by showNotificationGroups.
  * @param {ServerResponse} response Server response.
  * @return {Promise} A promise to process the server response and provide
  *     updated groups. Rejects if the server response shouldn't be processed.
  */
 function processServerResponse(response) {
   console.log('processServerResponse ' + JSON.stringify(response));
 
   if (response.googleNowDisabled) {
     chrome.storage.local.set({googleNowEnabled: false});
-    // TODO(robliao): Remove the line below once the server stops sending groups
-    // with 'googleNowDisabled' responses.
-    response.groups = {};
-    // Google Now was enabled; now it's disabled. This is a state change.
-    onStateChange();
-    // Start the Google Now Disabled polling period.
-    scheduleNextPoll({}, false);
     // Stop processing now. The state change will clear the cards.
     return Promise.reject();
   }
 
   var receivedGroups = response.groups;
 
   return fillFromChromeLocalStorage({
     /** @type {Object.<string, StoredNotificationGroup>} */
     notificationGroups: {},
     /** @type {Object.<ServerNotificationId, number>} */
@@ skipping 58 matching lines @@
       // 'nextPollSeconds' may be sent even for groups that don't contain
       // cards updates.
       if (receivedGroup.nextPollSeconds !== undefined) {
         storedGroup.nextPollTime =
             now + receivedGroup.nextPollSeconds * MS_IN_SECOND;
       }
 
       updatedGroups[groupName] = storedGroup;
     }
 
-    scheduleNextPoll(updatedGroups, !response.googleNowDisabled);
+    scheduleNextCardsPoll(updatedGroups);
     return {
       updatedGroups: updatedGroups,
       recentDismissals: updatedRecentDismissals
     };
   });
 }
 
 /**
  * Update the Explanatory Total Cards Shown Count.
  */
@@ skipping 44 matching lines @@
       console.log(
           'requestNotificationGroupsFromServer-received ' + request.status);
       if (request.status == HTTP_OK) {
         recordEvent(GoogleNowEvent.REQUEST_FOR_CARDS_SUCCESS);
         return JSON.parse(request.responseText);
       }
     });
 }
 
 /**
+ * Performs an opt-in poll without an immediate recheck.
+ * If the response is not opted-in, schedule an opt-in check poll.
+ */
+function pollOptedInNoImmediateRecheck() {
+  requestAndUpdateOptedIn()
+      .then(function(optedIn) {
+        if (!optedIn) {
+          // Request a repoll if we're not opted in.
+          return Promise.reject();
+        }
+      })
+      .catch(function() {
+        scheduleOptInCheckPoll();
+      });
+}
+
+/**
  * Requests the account opted-in state from the server and updates any
  * state as necessary.
  * @return {Promise} A promise to request and update the opted-in state.
- *     The promise resolves if the opt-in state is true.
+ *     The promise resolves with the opt-in state.
  */
 function requestAndUpdateOptedIn() {
   console.log('requestOptedIn from ' + NOTIFICATION_CARDS_URL);
 
   return requestFromServer('GET', 'settings/optin').then(function(request) {
     console.log(
         'requestOptedIn-received ' + request.status + ' ' + request.response);
     if (request.status == HTTP_OK) {
       var parsedResponse = JSON.parse(request.responseText);
       return parsedResponse.value;
     }
   }).then(function(optedIn) {
-    if (optedIn) {
-      chrome.storage.local.set({googleNowEnabled: true});
-      // Google Now was disabled, now it's enabled. This is a state change.
-      onStateChange();
-      return Promise.resolve();
-    } else {
-      scheduleNextPoll({}, false);
-      return Promise.reject();
-    }
+    chrome.storage.local.set({googleNowEnabled: optedIn});
+    return optedIn;
   });
 }
 
 /**
  * Determines the groups that need to be requested right now.
  * @return {Promise} A promise to determine the groups to request.
  */
 function getGroupsToRequest() {
   return fillFromChromeLocalStorage({
     /** @type {Object.<string, StoredNotificationGroup>} */
@@ skipping 12 matching lines @@
   });
 }
 
 /**
  * Requests notification cards from the server.
  * @return {Promise} A promise to request the notification cards.
  *     Rejects if the cards won't be requested.
  */
 function requestNotificationCards() {
   console.log('requestNotificationCards');
-
-  return isGoogleNowEnabled()
-      .then(function(googleNowEnabled) {
-        return googleNowEnabled ? Promise.resolve() : requestAndUpdateOptedIn();
-      })
-      .then(getGroupsToRequest)
+  return getGroupsToRequest()
       .then(requestNotificationGroupsFromServer)
       .then(processServerResponse)
       .then(function(processedResponse) {
         var onCardShown =
             shouldShowExplanatoryCard() ? countExplanatoryCard : undefined;
         return showNotificationGroups(
             processedResponse.updatedGroups, onCardShown).then(function() {
               chrome.storage.local.set({
                 notificationGroups: processedResponse.updatedGroups,
                 recentDismissals: processedResponse.updatedRecentDismissals
@@ skipping 10 matching lines @@
 function requestCards() {
   console.log('requestCards @' + new Date());
   // LOCATION_REQUEST is a legacy histogram value when we requested location.
   // This corresponds to the extension attempting to request for cards.
   // We're keeping the name the same to keep our histograms in order.
   recordEvent(GoogleNowEvent.LOCATION_REQUEST);
   tasks.add(UPDATE_CARDS_TASK_NAME, function() {
     console.log('requestCards-task-begin');
     updateCardsAttempts.isRunning(function(running) {
       if (running) {
-        updateCardsAttempts.planForNext(function() {
-          // The cards are requested only if there are no unsent dismissals.
-          processPendingDismissals().then(requestNotificationCards);
-        });
+        // The cards are requested only if there are no unsent dismissals.
+        processPendingDismissals()
+            .then(requestNotificationCards)
+            .catch(updateCardsAttempts.scheduleRetry);
       }
     });
   });
 }
 
 /**
  * Sends a server request to dismiss a card.
  * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
  *     the card.
  * @param {number} dismissalTimeMs Time of the user's dismissal of the card in
@@ skipping 96 matching lines @@
 
     return doProcessDismissals();
   });
 }
 
 /**
  * Submits a task to send pending dismissals.
  */
 function retryPendingDismissals() {
   tasks.add(RETRY_DISMISS_TASK_NAME, function() {
-    dismissalAttempts.planForNext(function() {
-      processPendingDismissals();
-     });
+    processPendingDismissals().catch(dismissalAttempts.scheduleRetry);
   });
 }
 
 /**
  * Opens a URL in a new tab.
  * @param {string} url URL to open.
  */
 function openUrl(url) {
   instrumented.tabs.create({url: url}, function(tab) {
     if (tab)
@@ skipping 132 matching lines @@
       else
         stopPollingCards();
     } else {
       console.log(
           'Action Ignored setShouldPollCards=' + shouldPollCardsRequest);
     }
   });
 }
 
 /**
+ * Starts or stops the optin check.
+ * @param {boolean} shouldPollOptInStatus true to start and false to stop
+ *     polling the optin status.
+ */
+function setShouldPollOptInStatus(shouldPollOptInStatus) {
+  optInPollAttempts.isRunning(function(currentValue) {
+    if (shouldPollOptInStatus != currentValue) {
+      console.log(
+          'Action Taken setShouldPollOptInStatus=' + shouldPollOptInStatus);
+      if (shouldPollOptInStatus) {
+        pollOptedInNoImmediateRecheck();
+      } else {
+        optInPollAttempts.stop();
+      }
+    } else {
+      console.log(
+          'Action Ignored setShouldPollOptInStatus=' + shouldPollOptInStatus);
+    }
+  });
+}
+
+/**
  * Enables or disables the Google Now background permission.
  * @param {boolean} backgroundEnable true to run in the background.
  *     false to not run in the background.
  */
 function setBackgroundEnable(backgroundEnable) {
   instrumented.permissions.contains({permissions: ['background']},
       function(hasPermission) {
         if (backgroundEnable != hasPermission) {
           console.log('Action Taken setBackgroundEnable=' + backgroundEnable);
           if (backgroundEnable)
@@ skipping 40 matching lines @@
     canEnableBackground,
     notificationEnabled,
     googleNowEnabled) {
   console.log(
       'State Update signedIn=' + signedIn + ' ' +
       'canEnableBackground=' + canEnableBackground + ' ' +
       'notificationEnabled=' + notificationEnabled + ' ' +
       'googleNowEnabled=' + googleNowEnabled);
 
   var shouldPollCards = false;
+  var shouldPollOptInStatus = false;
   var shouldSetBackground = false;
-  var shouldClearCards = true;
 
   if (signedIn && notificationEnabled) {
-    shouldClearCards = !googleNowEnabled;
+    shouldPollCards = googleNowEnabled;
+    shouldPollOptInStatus = !googleNowEnabled;
     shouldSetBackground = canEnableBackground && googleNowEnabled;
-    shouldPollCards = true;
   } else {
     recordEvent(GoogleNowEvent.STOPPED);
   }
 
   recordEventIfNoCards(signedIn, notificationEnabled, googleNowEnabled);
 
   console.log(
       'Requested Actions shouldSetBackground=' + shouldSetBackground + ' ' +
       'setShouldPollCards=' + shouldPollCards + ' ' +
-      'shouldClearCards=' + shouldClearCards);
+      'shouldPollOptInStatus=' + shouldPollOptInStatus);
 
   setBackgroundEnable(shouldSetBackground);
   setShouldPollCards(shouldPollCards);
-  if (shouldClearCards) {
+  setShouldPollOptInStatus(shouldPollOptInStatus);
+  if (!shouldPollCards) {
     removeAllCards();
   }
 }
 
 /**
  * Coordinates the behavior of Google Now for Chrome depending on
  * Chrome and extension state.
  */
 function onStateChange() {
   tasks.add(STATE_CHANGED_TASK_NAME, function() {
@@ skipping 45 matching lines @@
       .then(function(items) {
         return items.googleNowEnabled;
       });
 }
 
 /**
  * Polls the optin state.
  * Sometimes we get the response to the opted in result too soon during
  * push messaging. We'll recheck the optin state a few times before giving up.
  */
-function pollOptedIn() {
+function pollOptedInWithRecheck() {
   /**
    * Cleans up any state used to recheck the opt-in poll.
    */
   function clearPollingState() {
     localStorage.removeItem('optedInCheckCount');
-    optInCheckAttempts.stop();
+    optInRecheckAttempts.stop();
   }
 
   if (localStorage.optedInCheckCount === undefined) {
     localStorage.optedInCheckCount = 0;
-    optInCheckAttempts.start();
+    optInRecheckAttempts.start();
   }
 
   console.log(new Date() +
       ' checkOptedIn Attempt ' + localStorage.optedInCheckCount);
 
-  requestAndUpdateOptedIn().then(function() {
-    clearPollingState();
-    requestCards();
+  requestAndUpdateOptedIn().then(function(optedIn) {
+    if (optedIn) {
+      clearPollingState();
+      return Promise.resolve();
+    } else {
+      // If we're not opted in, reject to retry.
+      return Promise.reject();
+    }
   }).catch(function() {
     if (localStorage.optedInCheckCount < 5) {
       localStorage.optedInCheckCount++;
-      optInCheckAttempts.planForNext(function() {});
+      optInRecheckAttempts.scheduleRetry();
     } else {
       clearPollingState();
     }
   });
 }
 
 instrumented.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     initialize();
@@ skipping 63 matching lines @@
 instrumented.notifications.onPermissionLevelChanged.addListener(
     function(permissionLevel) {
       console.log('Notifications permissionLevel Change');
       onStateChange();
     });
 
 instrumented.notifications.onShowSettings.addListener(function() {
   openUrl(SETTINGS_URL);
 });
 
+// Handles state change notifications for the Google Now enabled bit.
+instrumented.storage.onChanged.addListener(function(changes, areaName) {
+  if (areaName === 'local') {
+    if ('googleNowEnabled' in changes) {
+      onStateChange();
+    }
+  }
+});
+
 instrumented.pushMessaging.onMessage.addListener(function(message) {
   // message.payload will be '' when the extension first starts.
   // Each time after signing in, we'll get latest payload for all channels.
   // So, we need to poll the server only when the payload is non-empty and has
   // changed.
   console.log('pushMessaging.onMessage ' + JSON.stringify(message));
   if (message.payload.indexOf('REQUEST_CARDS') == 0) {
     tasks.add(ON_PUSH_MESSAGE_START_TASK_NAME, function() {
       // Accept promise rejection on failure since it's safer to do nothing,
       // preventing polling the server when the payload really didn't change.
       fillFromChromeLocalStorage({
         lastPollNowPayloads: {},
         /** @type {Object.<string, StoredNotificationGroup>} */
         notificationGroups: {}
       }, PromiseRejection.ALLOW).then(function(items) {
         if (items.lastPollNowPayloads[message.subchannelId] !=
             message.payload) {
           items.lastPollNowPayloads[message.subchannelId] = message.payload;
 
           items.notificationGroups['PUSH' + message.subchannelId] = {
             cards: [],
             nextPollTime: Date.now()
           };
 
           chrome.storage.local.set({
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
-          pollOptedIn();
+          pollOptedInWithRecheck();
         }
       });
     });
   }
 });