Retries with exponential backoff for dismissals

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'; TODO(vadimt): Uncomment once crbug.com/237617 is fixed.
 
 /**
  * @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 35 matching lines @@
  * period from the server is not available.
  */
 var INITIAL_POLLING_PERIOD_SECONDS = 5 * 60;  // 5 minutes
 
 /**
  * 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
 
-var UPDATE_NOTIFICATIONS_ALARM_NAME = 'UPDATE';
+/**
+ * Initial period for retrying the server request for dismissing cards.
+ */
+var INITIAL_RETRY_DISMISS_PERIOD_SECONDS = 60;  // 1 minute
 
 /**
- * Period for retrying the server request for dismissing cards.
+ * Maximum period for retrying the server request for dismissing cards.
  */
-var RETRY_DISMISS_PERIOD_SECONDS = 60;  // 1 minute
-
-var RETRY_DISMISS_ALARM_NAME = 'RETRY_DISMISS';
+var MAXIMUM_RETRY_DISMISS_PERIOD_SECONDS = 60 * 60;  // 1 hour
 
 /**
  * Time we keep dismissals after successful server dismiss requests.
  */
 var DISMISS_RETENTION_TIME_MS = 20 * 60 * 1000;  // 20 minutes
 
-var storage = chrome.storage.local;
-
 /**
  * Names for tasks that can be created by the extension.
  */
 var UPDATE_CARDS_TASK_NAME = 'update-cards';
 var DISMISS_CARD_TASK_NAME = 'dismiss-card';
 var CARD_CLICKED_TASK_NAME = 'card-clicked';
 var RETRY_DISMISS_TASK_NAME = 'retry-dismiss';
 
 var LOCATION_WATCH_NAME = 'location-watch';
 
@@ skipping 32 matching lines @@
 tasks.instrumentApiFunction(chrome.notifications, 'update', 2);
 tasks.instrumentApiFunction(
     chrome.notifications.onButtonClicked, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.notifications.onClicked, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.notifications.onClosed, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.runtime.onInstalled, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.runtime.onStartup, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.tabs, 'create', 1);
 tasks.instrumentApiFunction(storage, 'get', 1);
 
+var updateCardsAttempts = buildAttemptManager(
+    'cards-update',
+    requestLocation,
+    INITIAL_POLLING_PERIOD_SECONDS,
+    MAXIMUM_POLLING_PERIOD_SECONDS);
+var dismissalAttempts = buildAttemptManager(
+    'dismiss',
+    retryPendingDismissals,
+    INITIAL_RETRY_DISMISS_PERIOD_SECONDS,
+    MAXIMUM_RETRY_DISMISS_PERIOD_SECONDS);
+
 /**
  * Diagnostic event identifier.
  * @enum {number}
  */
 var DiagnosticEvent = {
   REQUEST_FOR_CARDS_TOTAL: 0,
   REQUEST_FOR_CARDS_SUCCESS: 1,
   CARDS_PARSE_SUCCESS: 2,
   DISMISS_REQUEST_TOTAL: 3,
   DISMISS_REQUEST_SUCCESS: 4,
@@ skipping 152 matching lines @@
     for (var i = 0; i < cards.length; ++i) {
       var card = cards[i];
       if (!(card.notificationId in updatedRecentDismissals)) {
         var activeNotification = items.activeNotifications[card.notificationId];
         showNotification(card,
                          notificationsData,
                          activeNotification && activeNotification.version);
       }
     }
 
-    scheduleNextUpdate(parsedResponse.expiration_timestamp_seconds);
+    updateCardsAttempts.start(parsedResponse.expiration_timestamp_seconds);
 
-    // Now that we got a valid response from the server, reset the retry period
-    // to the initial value. This retry period will be used the next time we
-    // fail to get the server-provided period.
     storage.set({
-      retryDelaySeconds: INITIAL_POLLING_PERIOD_SECONDS,
       activeNotifications: notificationsData,
       recentDismissals: updatedRecentDismissals
     });
     callback();
   });
 }
 
 /**
  * Requests notification cards from the server.
  * @param {Location} position Location of this computer.
@@ skipping 52 matching lines @@
 /**
  * Obtains new location; requests and shows notification cards based on this
  * location.
  * @param {Location} position Location of this computer.
  */
 function updateNotificationsCards(position) {
   console.log('updateNotificationsCards ' + JSON.stringify(position) +
       ' @' + new Date());
   tasks.add(UPDATE_CARDS_TASK_NAME, function(callback) {
     console.log('updateNotificationsCards-task-begin');
-    tasks.debugSetStepName('updateNotificationsCards-get-retryDelaySeconds');
-    storage.get('retryDelaySeconds', function(items) {
-      console.log('updateNotificationsCards-get-retryDelaySeconds ' +
-                  JSON.stringify(items));
-      // Immediately schedule the update after the current retry period. Then,
-      // we'll use update time from the server if available.
-      scheduleNextUpdate(items.retryDelaySeconds);
-
-      // TODO(vadimt): Consider interrupting waiting for the next update if we
-      // detect that the network conditions have changed. Also, decide whether
-      // the exponential backoff is needed both when we are offline and when
-      // there are failures on the server side.
-      var newRetryDelaySeconds =
-          Math.min(items.retryDelaySeconds * 2 * (1 + 0.2 * Math.random()),
-                   MAXIMUM_POLLING_PERIOD_SECONDS);
-      storage.set({retryDelaySeconds: newRetryDelaySeconds});
-
+    updateCardsAttempts.planForNext(function() {
       processPendingDismissals(function(success) {
         if (success) {
           // The cards are requested only if there are no unsent dismissals.
           requestNotificationCards(position, callback);
         } else {
           callback();
         }
       });
     });
   });
@@ skipping 51 matching lines @@
         storage.set({
           pendingDismissals: items.pendingDismissals,
           recentDismissals: items.recentDismissals
         });
       }
       callbackBoolean(success);
     }
 
     function doProcessDismissals() {
       if (items.pendingDismissals.length == 0) {
-        chrome.alarms.clear(RETRY_DISMISS_ALARM_NAME);
+        dismissalAttempts.stop();
         onFinish(true);
         return;
       }
 
       // Send dismissal for the first card, and if successful, repeat
       // recursively with the rest.
       var dismissal = items.pendingDismissals[0];
       requestCardDismissal(
           dismissal.notificationId, dismissal.time, function(success) {
         if (success) {
           dismissalsChanged = true;
           items.pendingDismissals.splice(0, 1);
           items.recentDismissals[dismissal.notificationId] = Date.now();
           doProcessDismissals();
         } else {
           onFinish(false);
         }
       });
     }
 
     doProcessDismissals();
   });
 }
 
 /**
  * Submits a task to send pending dismissals.
  */
 function retryPendingDismissals() {
   tasks.add(RETRY_DISMISS_TASK_NAME, function(callback) {
-    processPendingDismissals(function(success) { callback(); });
+    dismissalAttempts.planForNext(function() {
+      processPendingDismissals(function(success) { callback(); });
+     });
   });
 }
 
 /**
  * Opens URL corresponding to the clicked part of the notification.
  * @param {string} notificationId Unique identifier of the notification.
  * @param {function(Object): string} selector Function that extracts the url for
  *     the clicked area from the button action URLs info.
  */
 function onNotificationClicked(notificationId, selector) {
@@ skipping 27 matching lines @@
  * @param {string} notificationId Unique identifier of the notification.
  * @param {boolean} byUser Whether the notification was closed by the user.
  */
 function onNotificationClosed(notificationId, byUser) {
   if (!byUser)
     return;
 
   chrome.metricsPrivate.recordUserAction('GoogleNow.Dismissed');
 
   tasks.add(DISMISS_CARD_TASK_NAME, function(callback) {
-    // Schedule retrying dismissing until all dismissals go through.
-    // TODO(vadimt): Implement exponential backoff and unify it with getting
-    // cards.
-    var alarmInfo = {
-      delayInMinutes: RETRY_DISMISS_PERIOD_SECONDS / 60,
-      periodInMinutes: RETRY_DISMISS_PERIOD_SECONDS / 60
-    };
-
-    chrome.alarms.create(RETRY_DISMISS_ALARM_NAME, alarmInfo);
+    dismissalAttempts.start();
 
     // Deleting the notification in case it was re-added while this task was
     // scheduled, waiting for execution.
     chrome.notifications.clear(
         notificationId,
         function() {});
 
     tasks.debugSetStepName('onNotificationClosed-get-pendingDismissals');
     storage.get('pendingDismissals', function(items) {
       var dismissal = {
         notificationId: notificationId,
         time: Date.now()
       };
       items.pendingDismissals.push(dismissal);
       storage.set({pendingDismissals: items.pendingDismissals});
       processPendingDismissals(function(success) { callback(); });
     });
   });
 }
 
 /**
- * Schedules next update for notification cards.
- * @param {int} delaySeconds Length of time in seconds after which the alarm
- *     event should fire.
- */
-function scheduleNextUpdate(delaySeconds) {
-  console.log('scheduleNextUpdate ' + delaySeconds);
-  // Schedule an alarm after the specified delay. 'periodInMinutes' is for the
-  // case when we fail to re-register the alarm.
-  var alarmInfo = {
-    delayInMinutes: delaySeconds / 60,
-    periodInMinutes: MAXIMUM_POLLING_PERIOD_SECONDS / 60
-  };
-
-  chrome.alarms.create(UPDATE_NOTIFICATIONS_ALARM_NAME, alarmInfo);
-}
-
-/**
  * Initializes the event page on install or on browser startup.
  */
 function initialize() {
+  // Create an update timer for a case when for some reason location request
+  // gets stuck.
+  updateCardsAttempts.start(MAXIMUM_POLLING_PERIOD_SECONDS);
+
   var initialStorage = {
     activeNotifications: {},
-    recentDismissals: {},
-    retryDelaySeconds: INITIAL_POLLING_PERIOD_SECONDS
+    recentDismissals: {}
   };
   storage.set(initialStorage);
 
-  // Create an update timer for a case when for some reason location request
-  // gets stuck.
-  scheduleNextUpdate(MAXIMUM_POLLING_PERIOD_SECONDS);
-
   requestLocation();
 }
 
 chrome.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     storage.set({pendingDismissals: []});
     initialize();
   }
 });
 
 chrome.runtime.onStartup.addListener(function() {
   console.log('onStartup');
   initialize();
 });
 
-chrome.alarms.onAlarm.addListener(function(alarm) {
-  if (alarm.name == UPDATE_NOTIFICATIONS_ALARM_NAME)
-    requestLocation();
-  else if (alarm.name == RETRY_DISMISS_ALARM_NAME)
-    retryPendingDismissals();
-});
-
 chrome.notifications.onClicked.addListener(
     function(notificationId) {
       chrome.metricsPrivate.recordUserAction('GoogleNow.MessageClicked');
       onNotificationClicked(notificationId, function(actionUrls) {
         return actionUrls.messageUrl;
       });
     });
 
 chrome.notifications.onButtonClicked.addListener(
     function(notificationId, buttonIndex) {
       chrome.metricsPrivate.recordUserAction(
           'GoogleNow.ButtonClicked' + buttonIndex);
       onNotificationClicked(notificationId, function(actionUrls) {
         if (!Array.isArray(actionUrls.buttonUrls))
           return undefined;
 
         return actionUrls.buttonUrls[buttonIndex];
       });
     });
 
 chrome.notifications.onClosed.addListener(onNotificationClosed);
 
 chrome.location.onLocationUpdate.addListener(updateNotificationsCards);