WIP: run clang-format-js on lots of things

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 58 matching lines @@
 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
 
 /**
  * Time we keep retrying dismissals.
  */
-var MAXIMUM_DISMISSAL_AGE_MS = 24 * 60 * 60 * 1000; // 1 day
+var MAXIMUM_DISMISSAL_AGE_MS = 24 * 60 * 60 * 1000;  // 1 day
 
 /**
  * Time we keep dismissals after successful server dismiss requests.
  */
 var DISMISS_RETENTION_TIME_MS = 20 * 60 * 1000;  // 20 minutes
 
 /**
  * Default period for checking whether the user is opted in to Google Now.
  */
-var DEFAULT_OPTIN_CHECK_PERIOD_SECONDS = 60 * 60 * 24 * 7; // 1 week
+var DEFAULT_OPTIN_CHECK_PERIOD_SECONDS = 60 * 60 * 24 * 7;  // 1 week
 
 /**
  * URL to open when the user clicked on a link for the our notification
  * settings.
  */
 var SETTINGS_URL = 'https://support.google.com/chrome/?p=ib_google_now_welcome';
 
 /**
  * GCM registration URL.
  */
@@ skipping 117 matching lines @@
     'notifications.onPermissionLevelChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onShowSettings.addListener', 0);
 wrapper.instrumentChromeApiFunction('permissions.contains', 1);
 wrapper.instrumentChromeApiFunction('runtime.onInstalled.addListener', 0);
 wrapper.instrumentChromeApiFunction('runtime.onStartup.addListener', 0);
 wrapper.instrumentChromeApiFunction('storage.onChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction('tabs.create', 1);
 
 var updateCardsAttempts = buildAttemptManager(
-    'cards-update',
-    requestCards,
-    INITIAL_POLLING_PERIOD_SECONDS,
+    'cards-update', requestCards, INITIAL_POLLING_PERIOD_SECONDS,
     MAXIMUM_POLLING_PERIOD_SECONDS);
 var optInPollAttempts = buildAttemptManager(
-    'optin',
-    pollOptedInNoImmediateRecheck,
-    INITIAL_POLLING_PERIOD_SECONDS,
+    'optin', 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);
+    'optin-recheck', pollOptedInWithRecheck,
+    INITIAL_OPTIN_RECHECK_PERIOD_SECONDS, MAXIMUM_OPTIN_RECHECK_PERIOD_SECONDS);
 var dismissalAttempts = buildAttemptManager(
-    'dismiss',
-    retryPendingDismissals,
-    INITIAL_RETRY_DISMISS_PERIOD_SECONDS,
+    'dismiss', retryPendingDismissals, INITIAL_RETRY_DISMISS_PERIOD_SECONDS,
     MAXIMUM_RETRY_DISMISS_PERIOD_SECONDS);
 var cardSet = buildCardSet();
 
 var authenticationManager = buildAuthenticationManager();
 
 /**
  * Google Now UMA event identifier.
  * @enum {number}
  */
 var GoogleNowEvent = {
@@ skipping 106 matching lines @@
  *     called when each card is shown.
  * @return {Promise} A promise to show the notification groups as cards.
  */
 function showNotificationGroups(notificationGroups, opt_onCardShown) {
   /** @type {Object<ChromeNotificationId, CombinedCard>} */
   var cards = combineCardsFromGroups(notificationGroups);
   console.log('showNotificationGroups ' + JSON.stringify(cards));
 
   return new Promise(function(resolve) {
     instrumented.notifications.getAll(function(notifications) {
-      console.log('showNotificationGroups-getAll ' +
-          JSON.stringify(notifications));
+      console.log(
+          'showNotificationGroups-getAll ' + JSON.stringify(notifications));
       notifications = notifications || {};
 
       // Mark notifications that didn't receive an update as having received
       // an empty update.
       for (var chromeNotificationId in notifications) {
         cards[chromeNotificationId] = cards[chromeNotificationId] || [];
       }
 
       /** @type {Object<ChromeNotificationId, NotificationDataEntry>} */
       var notificationsData = {};
 
       // Create/update/delete notifications.
       for (var chromeNotificationId in cards) {
         notificationsData[chromeNotificationId] = cardSet.update(
-            chromeNotificationId,
-            cards[chromeNotificationId],
-            notificationGroups,
-            opt_onCardShown);
+            chromeNotificationId, cards[chromeNotificationId],
+            notificationGroups, opt_onCardShown);
       }
       chrome.storage.local.set({notificationsData: notificationsData});
       resolve();
     });
   });
 }
 
 /**
  * Removes all cards and card state on Google Now close down.
  */
@@ skipping 22 matching lines @@
  */
 function combineGroup(combinedCards, storedGroup) {
   for (var i = 0; i < storedGroup.cards.length; i++) {
     /** @type {ReceivedNotification} */
     var receivedNotification = storedGroup.cards[i];
 
     /** @type {UncombinedNotification} */
     var uncombinedNotification = {
       receivedNotification: receivedNotification,
       showTime: receivedNotification.trigger.showTimeSec &&
-                (storedGroup.cardsTimestamp +
-                 receivedNotification.trigger.showTimeSec * MS_IN_SECOND),
+          (storedGroup.cardsTimestamp +
+           receivedNotification.trigger.showTimeSec * MS_IN_SECOND),
       hideTime: storedGroup.cardsTimestamp +
-                receivedNotification.trigger.hideTimeSec * MS_IN_SECOND
+          receivedNotification.trigger.hideTimeSec * MS_IN_SECOND
     };
 
     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<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);
+          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<StoredNotificationGroup>} groups Map from group name to group
  *     information.
  */
 function scheduleNextCardsPoll(groups) {
   var nextPollTimeMs = calculateNextPollTimeMilliseconds(groups);
 
   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) {
+  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<StoredNotificationGroup>} notificationGroups Map from group
@@ skipping 22 matching lines @@
 
   if (response.googleNowDisabled) {
     chrome.storage.local.set({googleNowEnabled: false});
     // Stop processing now. The state change will clear the cards.
     return Promise.reject();
   }
 
   var receivedGroups = response.groups;
 
   return fillFromChromeLocalStorage({
-    /** @type {Object<StoredNotificationGroup>} */
-    notificationGroups: {},
-    /** @type {Object<ServerNotificationId, number>} */
-    recentDismissals: {}
-  }).then(function(items) {
-    console.log('processServerResponse-get ' + JSON.stringify(items));
+           /** @type {Object<StoredNotificationGroup>} */
+           notificationGroups: {},
+           /** @type {Object<ServerNotificationId, number>} */
+           recentDismissals: {}
+         })
+      .then(function(items) {
+        console.log('processServerResponse-get ' + JSON.stringify(items));
 
-    // Build a set of non-expired recent dismissals. It will be used for
-    // client-side filtering of cards.
-    /** @type {Object<ServerNotificationId, number>} */
-    var updatedRecentDismissals = {};
-    var now = Date.now();
-    for (var serverNotificationId in items.recentDismissals) {
-      var dismissalAge = now - items.recentDismissals[serverNotificationId];
-      if (dismissalAge < DISMISS_RETENTION_TIME_MS) {
-        updatedRecentDismissals[serverNotificationId] =
-            items.recentDismissals[serverNotificationId];
-      }
-    }
+        // Build a set of non-expired recent dismissals. It will be used for
+        // client-side filtering of cards.
+        /** @type {Object<ServerNotificationId, number>} */
+        var updatedRecentDismissals = {};
+        var now = Date.now();
+        for (var serverNotificationId in items.recentDismissals) {
+          var dismissalAge = now - items.recentDismissals[serverNotificationId];
+          if (dismissalAge < DISMISS_RETENTION_TIME_MS) {
+            updatedRecentDismissals[serverNotificationId] =
+                items.recentDismissals[serverNotificationId];
+          }
+        }
 
-    // Populate groups with corresponding cards.
-    if (response.notifications) {
-      for (var i = 0; i < response.notifications.length; ++i) {
-        /** @type {ReceivedNotification} */
-        var card = response.notifications[i];
-        if (!(card.notificationId in updatedRecentDismissals)) {
-          var group = receivedGroups[card.groupName];
-          group.cards = group.cards || [];
-          group.cards.push(card);
+        // Populate groups with corresponding cards.
+        if (response.notifications) {
+          for (var i = 0; i < response.notifications.length; ++i) {
+            /** @type {ReceivedNotification} */
+            var card = response.notifications[i];
+            if (!(card.notificationId in updatedRecentDismissals)) {
+              var group = receivedGroups[card.groupName];
+              group.cards = group.cards || [];
+              group.cards.push(card);
+            }
+          }
         }
-      }
-    }
 
-    // Build updated set of groups.
-    var updatedGroups = {};
+        // Build updated set of groups.
+        var updatedGroups = {};
 
-    for (var groupName in receivedGroups) {
-      var receivedGroup = receivedGroups[groupName];
-      var storedGroup = items.notificationGroups[groupName] || {
-        cards: [],
-        cardsTimestamp: undefined,
-        nextPollTime: undefined,
-        rank: undefined
-      };
+        for (var groupName in receivedGroups) {
+          var receivedGroup = receivedGroups[groupName];
+          var storedGroup = items.notificationGroups[groupName] || {
+            cards: [],
+            cardsTimestamp: undefined,
+            nextPollTime: undefined,
+            rank: undefined
+          };
 
-      if (receivedGroup.requested)
-        receivedGroup.cards = receivedGroup.cards || [];
+          if (receivedGroup.requested)
+            receivedGroup.cards = receivedGroup.cards || [];
 
-      if (receivedGroup.cards) {
-        // If the group contains a cards update, all its fields will get new
-        // values.
-        storedGroup.cards = receivedGroup.cards;
-        storedGroup.cardsTimestamp = now;
-        storedGroup.rank = receivedGroup.rank;
-        storedGroup.nextPollTime = undefined;
-        // The code below assigns nextPollTime a defined value if
-        // nextPollSeconds is specified in the received group.
-        // If the group's cards are not updated, and nextPollSeconds is
-        // unspecified, this method doesn't change group's nextPollTime.
-      }
+          if (receivedGroup.cards) {
+            // If the group contains a cards update, all its fields will get new
+            // values.
+            storedGroup.cards = receivedGroup.cards;
+            storedGroup.cardsTimestamp = now;
+            storedGroup.rank = receivedGroup.rank;
+            storedGroup.nextPollTime = undefined;
+            // The code below assigns nextPollTime a defined value if
+            // nextPollSeconds is specified in the received group.
+            // If the group's cards are not updated, and nextPollSeconds is
+            // unspecified, this method doesn't change group's nextPollTime.
+          }
 
-      // '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;
-      }
+          // '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;
-    }
+          updatedGroups[groupName] = storedGroup;
+        }
 
-    scheduleNextCardsPoll(updatedGroups);
-    return {
-      updatedGroups: updatedGroups,
-      recentDismissals: updatedRecentDismissals
-    };
-  });
+        scheduleNextCardsPoll(updatedGroups);
+        return {
+          updatedGroups: updatedGroups,
+          recentDismissals: updatedRecentDismissals
+        };
+      });
 }
 
 /**
  * Update the Explanatory Total Cards Shown Count.
  */
 function countExplanatoryCard() {
   localStorage['explanatoryCardsShown']++;
 }
 
 /**
@@ skipping 11 matching lines @@
  * @param {Array<string>} groupNames Names of groups that need to be refreshed.
  * @return {Promise} A promise to request the specified notification groups.
  */
 function requestNotificationGroupsFromServer(groupNames) {
   console.log(
       'requestNotificationGroupsFromServer from ' + NOTIFICATION_CARDS_URL +
       ', groupNames=' + JSON.stringify(groupNames));
 
   recordEvent(GoogleNowEvent.REQUEST_FOR_CARDS_TOTAL);
 
-  var requestParameters = '?timeZoneOffsetMs=' +
-    (-new Date().getTimezoneOffset() * MS_IN_MINUTE);
+  var requestParameters =
+      '?timeZoneOffsetMs=' + (-new Date().getTimezoneOffset() * MS_IN_MINUTE);
 
   if (shouldShowExplanatoryCard()) {
     requestParameters += '&cardExplanation=true';
   }
 
   groupNames.forEach(function(groupName) {
     requestParameters += ('&requestTypes=' + groupName);
   });
 
   requestParameters += '&uiLocale=' + navigator.language;
 
   console.log(
       'requestNotificationGroupsFromServer: request=' + requestParameters);
 
-  return requestFromServer('GET', 'notifications' + requestParameters).then(
-    function(request) {
-      console.log(
-          'requestNotificationGroupsFromServer-received ' + request.status);
-      if (request.status == HTTP_OK) {
-        recordEvent(GoogleNowEvent.REQUEST_FOR_CARDS_SUCCESS);
-        return JSON.parse(request.responseText);
-      }
-    });
+  return requestFromServer('GET', 'notifications' + requestParameters)
+      .then(function(request) {
+        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 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) {
-    chrome.storage.local.set({googleNowEnabled: optedIn});
-    return optedIn;
-  });
+  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) {
+        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<StoredNotificationGroup>} */
-    notificationGroups: {}
-  }).then(function(items) {
-    console.log('getGroupsToRequest-storage-get ' + JSON.stringify(items));
-    var groupsToRequest = [];
-    var now = Date.now();
+           /** @type {Object<StoredNotificationGroup>} */
+           notificationGroups: {}
+         })
+      .then(function(items) {
+        console.log('getGroupsToRequest-storage-get ' + JSON.stringify(items));
+        var groupsToRequest = [];
+        var now = Date.now();
 
-    for (var groupName in items.notificationGroups) {
-      var group = items.notificationGroups[groupName];
-      if (group.nextPollTime !== undefined && group.nextPollTime <= now)
-        groupsToRequest.push(groupName);
-    }
-    return groupsToRequest;
-  });
+        for (var groupName in items.notificationGroups) {
+          var group = items.notificationGroups[groupName];
+          if (group.nextPollTime !== undefined && group.nextPollTime <= now)
+            groupsToRequest.push(groupName);
+        }
+        return groupsToRequest;
+      });
 }
 
 /**
  * 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 getGroupsToRequest()
       .then(requestNotificationGroupsFromServer)
       .then(processServerResponse)
       .then(function(processedResponse) {
         var onCardShown =
             shouldShowExplanatoryCard() ? countExplanatoryCard : undefined;
         return showNotificationGroups(
-            processedResponse.updatedGroups, onCardShown).then(function() {
+                   processedResponse.updatedGroups, onCardShown)
+            .then(function() {
               chrome.storage.local.set({
                 notificationGroups: processedResponse.updatedGroups,
                 recentDismissals: processedResponse.updatedRecentDismissals
               });
               recordEvent(GoogleNowEvent.CARDS_PARSE_SUCCESS);
-            }
-          );
+            });
       });
 }
 
 /**
  * Determines if an immediate retry should occur based off of the given groups.
  * The NOR group is expected most often and less latency sensitive, so we will
  * simply wait MAXIMUM_POLLING_PERIOD_SECONDS before trying again.
  * @param {Array<string>} groupNames Names of groups that need to be refreshed.
  * @return {boolean} Whether a retry should occur.
  */
@@ skipping 33 matching lines @@
  * 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
  *     milliseconds since epoch.
  * @param {DismissalData} dismissalData Data to build a dismissal request.
  * @return {Promise} A promise to request the card dismissal, rejects on error.
  */
 function requestCardDismissal(
     chromeNotificationId, dismissalTimeMs, dismissalData) {
-  console.log('requestDismissingCard ' + chromeNotificationId +
-      ' from ' + NOTIFICATION_CARDS_URL +
-      ', dismissalData=' + JSON.stringify(dismissalData));
+  console.log(
+      'requestDismissingCard ' + chromeNotificationId + ' from ' +
+      NOTIFICATION_CARDS_URL + ', dismissalData=' +
+      JSON.stringify(dismissalData));
 
   var dismissalAge = Date.now() - dismissalTimeMs;
 
   if (dismissalAge > MAXIMUM_DISMISSAL_AGE_MS) {
     return Promise.resolve();
   }
 
   recordEvent(GoogleNowEvent.DISMISS_REQUEST_TOTAL);
 
   var requestParameters = 'notifications/' + dismissalData.notificationId +
-      '?age=' + dismissalAge +
-      '&chromeNotificationId=' + chromeNotificationId;
+      '?age=' + dismissalAge + '&chromeNotificationId=' + chromeNotificationId;
 
   for (var paramField in dismissalData.parameters)
-    requestParameters += ('&' + paramField +
-    '=' + dismissalData.parameters[paramField]);
+    requestParameters +=
+        ('&' + paramField + '=' + dismissalData.parameters[paramField]);
 
   console.log('requestCardDismissal: requestParameters=' + requestParameters);
 
-  return requestFromServer('DELETE', requestParameters).then(function(request) {
-    console.log('requestDismissingCard-onloadend ' + request.status);
-    if (request.status == HTTP_NOCONTENT)
-      recordEvent(GoogleNowEvent.DISMISS_REQUEST_SUCCESS);
+  return requestFromServer('DELETE', requestParameters)
+      .then(function(request) {
+        console.log('requestDismissingCard-onloadend ' + request.status);
+        if (request.status == HTTP_NOCONTENT)
+          recordEvent(GoogleNowEvent.DISMISS_REQUEST_SUCCESS);
 
-    // A dismissal doesn't require further retries if it was successful or
-    // doesn't have a chance for successful completion.
-    return (request.status == HTTP_NOCONTENT) ?
-           Promise.resolve() :
-           Promise.reject();
-  }).catch(function(request) {
-    request = (typeof request === 'object') ? request : {};
-    return (request.status == HTTP_BAD_REQUEST ||
-           request.status == HTTP_METHOD_NOT_ALLOWED) ?
-           Promise.resolve() :
-           Promise.reject();
-  });
+        // A dismissal doesn't require further retries if it was successful or
+        // doesn't have a chance for successful completion.
+        return (request.status == HTTP_NOCONTENT) ? Promise.resolve() :
+                                                    Promise.reject();
+      })
+      .catch(function(request) {
+        request = (typeof request === 'object') ? request : {};
+        return (request.status == HTTP_BAD_REQUEST ||
+                request.status == HTTP_METHOD_NOT_ALLOWED) ?
+            Promise.resolve() :
+            Promise.reject();
+      });
 }
 
 /**
  * Tries to send dismiss requests for all pending dismissals.
  * @return {Promise} A promise to process the pending dismissals.
  *     The promise is rejected if a problem was encountered.
  */
 function processPendingDismissals() {
   return fillFromChromeLocalStorage({
-    /** @type {Array<PendingDismissal>} */
-    pendingDismissals: [],
-    /** @type {Object<ServerNotificationId, number>} */
-    recentDismissals: {}
-  }).then(function(items) {
-    console.log(
-        'processPendingDismissals-storage-get ' + JSON.stringify(items));
+           /** @type {Array<PendingDismissal>} */
+           pendingDismissals: [],
+           /** @type {Object<ServerNotificationId, number>} */
+           recentDismissals: {}
+         })
+      .then(function(items) {
+        console.log(
+            'processPendingDismissals-storage-get ' + JSON.stringify(items));
 
-    var dismissalsChanged = false;
+        var dismissalsChanged = false;
 
-    function onFinish(success) {
-      if (dismissalsChanged) {
-        chrome.storage.local.set({
-          pendingDismissals: items.pendingDismissals,
-          recentDismissals: items.recentDismissals
-        });
-      }
-      return success ? Promise.resolve() : Promise.reject();
-    }
+        function onFinish(success) {
+          if (dismissalsChanged) {
+            chrome.storage.local.set({
+              pendingDismissals: items.pendingDismissals,
+              recentDismissals: items.recentDismissals
+            });
+          }
+          return success ? Promise.resolve() : Promise.reject();
+        }
 
-    function doProcessDismissals() {
-      if (items.pendingDismissals.length == 0) {
-        dismissalAttempts.stop();
-        return onFinish(true);
-      }
+        function doProcessDismissals() {
+          if (items.pendingDismissals.length == 0) {
+            dismissalAttempts.stop();
+            return onFinish(true);
+          }
 
-      // Send dismissal for the first card, and if successful, repeat
-      // recursively with the rest.
-      /** @type {PendingDismissal} */
-      var dismissal = items.pendingDismissals[0];
-      return requestCardDismissal(
-          dismissal.chromeNotificationId,
-          dismissal.time,
-          dismissal.dismissalData).then(function() {
-            dismissalsChanged = true;
-            items.pendingDismissals.splice(0, 1);
-            items.recentDismissals[dismissal.dismissalData.notificationId] =
-                Date.now();
-            return doProcessDismissals();
-          }).catch(function() {
-            return onFinish(false);
-          });
-    }
+          // Send dismissal for the first card, and if successful, repeat
+          // recursively with the rest.
+          /** @type {PendingDismissal} */
+          var dismissal = items.pendingDismissals[0];
+          return requestCardDismissal(
+                     dismissal.chromeNotificationId, dismissal.time,
+                     dismissal.dismissalData)
+              .then(function() {
+                dismissalsChanged = true;
+                items.pendingDismissals.splice(0, 1);
+                items.recentDismissals[dismissal.dismissalData.notificationId] =
+                    Date.now();
+                return doProcessDismissals();
+              })
+              .catch(function() {
+                return onFinish(false);
+              });
+        }
 
-    return doProcessDismissals();
-  });
+        return doProcessDismissals();
+      });
 }
 
 /**
  * Submits a task to send pending dismissals.
  */
 function retryPendingDismissals() {
   tasks.add(RETRY_DISMISS_TASK_NAME, function() {
     processPendingDismissals().catch(dismissalAttempts.scheduleRetry);
   });
 }
@@ skipping 55 matching lines @@
 
     fillFromChromeLocalStorage({
       /** @type {Array<PendingDismissal>} */
       pendingDismissals: [],
       /** @type {Object<ChromeNotificationId, NotificationDataEntry>} */
       notificationsData: {},
       /** @type {Object<StoredNotificationGroup>} */
       notificationGroups: {}
     }).then(function(items) {
       /** @type {NotificationDataEntry} */
-      var notificationData =
-          items.notificationsData[chromeNotificationId] ||
-          {
-            timestamp: Date.now(),
-            combinedCard: []
-          };
+      var notificationData = items.notificationsData[chromeNotificationId] ||
+          {timestamp: Date.now(), combinedCard: []};
 
-      var dismissalResult =
-          cardSet.onDismissal(
-              chromeNotificationId,
-              notificationData,
-              items.notificationGroups);
+      var dismissalResult = cardSet.onDismissal(
+          chromeNotificationId, notificationData, items.notificationGroups);
 
       for (var i = 0; i < dismissalResult.dismissals.length; i++) {
         /** @type {PendingDismissal} */
         var dismissal = {
           chromeNotificationId: chromeNotificationId,
           time: Date.now(),
           dismissalData: dismissalResult.dismissals[i]
         };
         items.pendingDismissals.push(dismissal);
       }
@@ skipping 87 matching lines @@
     unregisterFromGcm();
   }
 }
 
 /**
  * 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) {
+  instrumented.permissions.contains(
+      {permissions: ['background']}, function(hasPermission) {
         if (backgroundEnable != hasPermission) {
           console.log('Action Taken setBackgroundEnable=' + backgroundEnable);
           if (backgroundEnable)
             chrome.permissions.request({permissions: ['background']});
           else
             chrome.permissions.remove({permissions: ['background']});
         } else {
           console.log('Action Ignored setBackgroundEnable=' + backgroundEnable);
         }
       });
@@ skipping 22 matching lines @@
  * based off of the current state of Chrome.
  * @param {boolean} signedIn true if the user is signed in.
  * @param {boolean} canEnableBackground true if
  *     the background permission can be requested.
  * @param {boolean} notificationEnabled true if
  *     Google Now for Chrome is allowed to show notifications.
  * @param {boolean} googleNowEnabled true if
  *     the Google Now is enabled for the user.
  */
 function updateRunningState(
-    signedIn,
-    canEnableBackground,
-    notificationEnabled,
-    googleNowEnabled) {
+    signedIn, canEnableBackground, notificationEnabled, googleNowEnabled) {
   console.log(
       'State Update signedIn=' + signedIn + ' ' +
       'canEnableBackground=' + canEnableBackground + ' ' +
       'notificationEnabled=' + notificationEnabled + ' ' +
       'googleNowEnabled=' + googleNowEnabled);
 
   var shouldPollCards = false;
   var shouldPollOptInStatus = false;
   var shouldSetBackground = false;
 
@@ skipping 19 matching lines @@
     removeAllCards();
   }
 }
 
 /**
  * Coordinates the behavior of Google Now for Chrome depending on
  * Chrome and extension state.
  */
 function onStateChange() {
   tasks.add(STATE_CHANGED_TASK_NAME, function() {
-    Promise.all([
-        authenticationManager.isSignedIn(),
-        canEnableBackground(),
-        isNotificationsEnabled(),
-        isGoogleNowEnabled()])
+    Promise
+        .all([
+          authenticationManager.isSignedIn(), canEnableBackground(),
+          isNotificationsEnabled(), isGoogleNowEnabled()
+        ])
         .then(function(results) {
           updateRunningState.apply(null, results);
         });
   });
 }
 
 /**
  * Determines if background mode should be requested.
  * @return {Promise} A promise to determine if background can be enabled.
  */
 function canEnableBackground() {
   return new Promise(function(resolve) {
     instrumented.metricsPrivate.getVariationParams(
-        'GoogleNow',
-        function(response) {
+        'GoogleNow', function(response) {
           resolve(!response || (response.canEnableBackground != 'false'));
         });
   });
 }
 
 /**
  * Checks if Google Now is enabled in the notifications center.
  * @return {Promise} A promise to determine if Google Now is enabled
  *     in the notifications center.
  */
@@ skipping 41 matching lines @@
       });
 }
 
 /**
  * Returns a promise resolving to a GCM Notificaiton Key. May call
  * chrome.gcm.register() first if required. Rejects on registration failure.
  * @return {Promise} A Promise that resolves to a fresh GCM Notification key.
  */
 function requestNewGcmNotificationKey() {
   return getGcmRegistrationId().then(function(gcmId) {
-    authenticationManager.getAuthToken().then(function(token) {
-      authenticationManager.getLogin().then(function(username) {
-        return new Promise(function(resolve, reject) {
-          var xhr = new XMLHttpRequest();
-          xhr.responseType = 'application/json';
-          xhr.open('POST', GCM_REGISTRATION_URL, true);
-          xhr.setRequestHeader('Content-Type', 'application/json');
-          xhr.setRequestHeader('Authorization', 'Bearer ' + token);
-          xhr.setRequestHeader('project_id', GCM_PROJECT_ID);
-          var payload = {
-            'operation': 'add',
-            'notification_key_name': username,
-            'registration_ids': [gcmId]
-          };
-          xhr.onloadend = function() {
-            if (xhr.status != 200) {
-              reject();
-            }
-            var obj = JSON.parse(xhr.responseText);
-            var key = obj && obj.notification_key;
-            if (!key) {
-              reject();
-            }
-            console.log('gcm notification key POST: ' + key);
-            chrome.storage.local.set({gcmNotificationKey: key});
-            resolve(key);
-          };
-          xhr.send(JSON.stringify(payload));
+    authenticationManager.getAuthToken()
+        .then(function(token) {
+          authenticationManager.getLogin().then(function(username) {
+            return new Promise(function(resolve, reject) {
+              var xhr = new XMLHttpRequest();
+              xhr.responseType = 'application/json';
+              xhr.open('POST', GCM_REGISTRATION_URL, true);
+              xhr.setRequestHeader('Content-Type', 'application/json');
+              xhr.setRequestHeader('Authorization', 'Bearer ' + token);
+              xhr.setRequestHeader('project_id', GCM_PROJECT_ID);
+              var payload = {
+                'operation': 'add',
+                'notification_key_name': username,
+                'registration_ids': [gcmId]
+              };
+              xhr.onloadend = function() {
+                if (xhr.status != 200) {
+                  reject();
+                }
+                var obj = JSON.parse(xhr.responseText);
+                var key = obj && obj.notification_key;
+                if (!key) {
+                  reject();
+                }
+                console.log('gcm notification key POST: ' + key);
+                chrome.storage.local.set({gcmNotificationKey: key});
+                resolve(key);
+              };
+              xhr.send(JSON.stringify(payload));
+            });
+          });
+        })
+        .catch(function() {
+          // Couldn't obtain a GCM ID. Ignore and fallback to polling.
         });
-      });
-    }).catch(function() {
-      // Couldn't obtain a GCM ID. Ignore and fallback to polling.
-    });
   });
 }
 
 /**
  * Returns a promise resolving to either a cached or new GCM registration ID.
  * Rejects if registration fails.
  * @return {Promise} A Promise that resolves to a GCM registration ID.
  */
 function getGcmRegistrationId() {
   return fillFromChromeLocalStorage({gcmRegistrationId: undefined})
@@ skipping 14 matching lines @@
             }
           });
         });
       });
 }
 
 /**
  * Unregisters from GCM if previously registered.
  */
 function unregisterFromGcm() {
-  fillFromChromeLocalStorage({gcmRegistrationId: undefined})
-      .then(function(items) {
-        if (items.gcmRegistrationId) {
-          console.log('Unregistering from gcm.');
-          instrumented.gcm.unregister(function() {
-            if (!chrome.runtime.lastError) {
-              chrome.storage.local.remove(
-                ['gcmNotificationKey', 'gcmRegistrationId']);
-            }
-          });
+  fillFromChromeLocalStorage({
+    gcmRegistrationId: undefined
+  }).then(function(items) {
+    if (items.gcmRegistrationId) {
+      console.log('Unregistering from gcm.');
+      instrumented.gcm.unregister(function() {
+        if (!chrome.runtime.lastError) {
+          chrome.storage.local.remove(
+              ['gcmNotificationKey', 'gcmRegistrationId']);
         }
       });
+    }
+  });
 }
 
 /**
  * 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 pollOptedInWithRecheck() {
   /**
    * Cleans up any state used to recheck the opt-in poll.
    */
   function clearPollingState() {
     localStorage.removeItem('optedInCheckCount');
     optInRecheckAttempts.stop();
   }
 
   if (localStorage.optedInCheckCount === undefined) {
     localStorage.optedInCheckCount = 0;
     optInRecheckAttempts.start();
   }
 
-  console.log(new Date() +
-      ' checkOptedIn Attempt ' + localStorage.optedInCheckCount);
+  console.log(
+      new Date() + ' checkOptedIn Attempt ' + localStorage.optedInCheckCount);
 
-  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++;
-      optInRecheckAttempts.scheduleRetry();
-    } else {
-      clearPollingState();
-    }
-  });
+  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++;
+          optInRecheckAttempts.scheduleRetry();
+        } else {
+          clearPollingState();
+        }
+      });
 }
 
 instrumented.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     initialize();
   }
 });
 
 instrumented.runtime.onStartup.addListener(function() {
@@ skipping 16 matching lines @@
   });
 
   initialize();
 });
 
 authenticationManager.addListener(function() {
   console.log('signIn State Change');
   onStateChange();
 });
 
-instrumented.notifications.onClicked.addListener(
-    function(chromeNotificationId) {
-      chrome.metricsPrivate.recordUserAction('GoogleNow.MessageClicked');
-      onNotificationClicked(chromeNotificationId,
-          function(notificationDataEntry) {
-            var actionUrls = notificationDataEntry.actionUrls;
-            var url = actionUrls && actionUrls.messageUrl;
-            if (url) {
-              recordNotificationClick(notificationDataEntry.cardTypeId);
-            }
-            return url;
-          });
-        });
+instrumented.notifications.onClicked.addListener(function(
+    chromeNotificationId) {
+  chrome.metricsPrivate.recordUserAction('GoogleNow.MessageClicked');
+  onNotificationClicked(chromeNotificationId, function(notificationDataEntry) {
+    var actionUrls = notificationDataEntry.actionUrls;
+    var url = actionUrls && actionUrls.messageUrl;
+    if (url) {
+      recordNotificationClick(notificationDataEntry.cardTypeId);
+    }
+    return url;
+  });
+});
 
-instrumented.notifications.onButtonClicked.addListener(
-    function(chromeNotificationId, buttonIndex) {
-      chrome.metricsPrivate.recordUserAction(
-          'GoogleNow.ButtonClicked' + buttonIndex);
-      onNotificationClicked(chromeNotificationId,
-          function(notificationDataEntry) {
-            var actionUrls = notificationDataEntry.actionUrls;
-            var url = actionUrls.buttonUrls[buttonIndex];
-            if (url) {
-              recordButtonClick(notificationDataEntry.cardTypeId, buttonIndex);
-            } else {
-              verify(false, 'onButtonClicked: no url for a button');
-              console.log(
-                  'buttonIndex=' + buttonIndex + ' ' +
-                  'chromeNotificationId=' + chromeNotificationId + ' ' +
-                  'notificationDataEntry=' +
-                  JSON.stringify(notificationDataEntry));
-            }
-            return url;
-          });
-        });
+instrumented.notifications.onButtonClicked.addListener(function(
+    chromeNotificationId, buttonIndex) {
+  chrome.metricsPrivate.recordUserAction(
+      'GoogleNow.ButtonClicked' + buttonIndex);
+  onNotificationClicked(chromeNotificationId, function(notificationDataEntry) {
+    var actionUrls = notificationDataEntry.actionUrls;
+    var url = actionUrls.buttonUrls[buttonIndex];
+    if (url) {
+      recordButtonClick(notificationDataEntry.cardTypeId, buttonIndex);
+    } else {
+      verify(false, 'onButtonClicked: no url for a button');
+      console.log(
+          'buttonIndex=' + buttonIndex + ' ' +
+          'chromeNotificationId=' + chromeNotificationId + ' ' +
+          'notificationDataEntry=' + JSON.stringify(notificationDataEntry));
+    }
+    return url;
+  });
+});
 
 instrumented.notifications.onClosed.addListener(onNotificationClosed);
 
-instrumented.notifications.onPermissionLevelChanged.addListener(
-    function(permissionLevel) {
-      console.log('Notifications permissionLevel Change');
-      onStateChange();
-    });
+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.gcm.onMessage.addListener(function(message) {
   console.log('gcm.onMessage ' + JSON.stringify(message));
   if (!message || !message.data) {
     return;
   }
 
   var payload = message.data.payload;
   var tag = message.data.tag;
   if (payload.startsWith('REQUEST_CARDS')) {
     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<StoredNotificationGroup>} */
-        notificationGroups: {}
-      }, PromiseRejection.ALLOW).then(function(items) {
-        if (items.lastPollNowPayloads[tag] != payload) {
-          items.lastPollNowPayloads[tag] = payload;
+      fillFromChromeLocalStorage(
+          {
+            lastPollNowPayloads: {},
+            /** @type {Object<StoredNotificationGroup>} */
+            notificationGroups: {}
+          },
+          PromiseRejection.ALLOW)
+          .then(function(items) {
+            if (items.lastPollNowPayloads[tag] != payload) {
+              items.lastPollNowPayloads[tag] = payload;
 
-          items.notificationGroups['PUSH' + tag] = {
-            cards: [],
-            nextPollTime: Date.now()
-          };
+              items.notificationGroups['PUSH' + tag] = {
+                cards: [],
+                nextPollTime: Date.now()
+              };
 
-          chrome.storage.local.set({
-            lastPollNowPayloads: items.lastPollNowPayloads,
-            notificationGroups: items.notificationGroups
+              chrome.storage.local.set({
+                lastPollNowPayloads: items.lastPollNowPayloads,
+                notificationGroups: items.notificationGroups
+              });
+
+              pollOptedInWithRecheck();
+            }
           });
-
-          pollOptedInWithRecheck();
-        }
-      });
     });
   }
 });