Restoring notifications on startup

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.
  * The service performs periodic updating of Google Now cards.
  * Each updating of the cards includes 4 steps:
  * 1. Obtaining the location of the machine;
  * 2. Processing requests for cards dismissals that are not yet sent to the
  *    server;
  * 3. Making a server request based on that location;
  * 4. Showing the received cards as notifications.
  */
 
 // TODO(vadimt): Decide what to do in incognito mode.
 // TODO(vadimt): Figure out the final values of the constants.
 // TODO(vadimt): Remove 'console' calls.
-// TODO(vadimt): Consider sending JS stacks for malformed server responses.
 
 /**
  * Standard response code for successful HTTP requests. This is the only success
  * code the server will send.
  */
 var HTTP_OK = 200;
 var HTTP_NOCONTENT = 204;
 
 var HTTP_BAD_REQUEST = 400;
 var HTTP_UNAUTHORIZED = 401;
@@ skipping 40 matching lines @@
  */
 var DISMISS_RETENTION_TIME_MS = 20 * 60 * 1000;  // 20 minutes
 
 /**
  * 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 RETRY_DISMISS_TASK_NAME = 'retry-dismiss';
 var STATE_CHANGED_TASK_NAME = 'state-changed';
+var SHOW_ON_START_TASK_NAME = 'show-cards-on-start';
 
 var LOCATION_WATCH_NAME = 'location-watch';
 
 var WELCOME_TOAST_NOTIFICATION_ID = 'enable-now-toast';
 
 /**
  * The indices of the buttons that are displayed on the welcome toast.
  * @enum {number}
  */
 var ToastButtonIndex = {YES: 0, NO: 1};
@@ skipping 216 matching lines @@
             var previousVersion = notifications[chromeNotificationId] &&
                                   notificationData &&
                                   notificationData.cardCreateInfo &&
                                   notificationData.cardCreateInfo.version;
             newNotificationsData[chromeNotificationId] = cardSet.update(
                 chromeNotificationId,
                 cards[chromeNotificationId],
                 previousVersion);
           }
 
-          recordEvent(GoogleNowEvent.CARDS_PARSE_SUCCESS);
-
           chrome.storage.local.set({
             notificationsData: newNotificationsData,
             recentDismissals: updatedRecentDismissals
           });
         });
       });
 }
 
 /**
  * Removes all cards and card state on Google Now close down.
@@ skipping 108 matching lines @@
 
   verify(nextPollTime != null, 'scheduleNextPoll: nextPollTime is null');
 
   var nextPollDelaySeconds = Math.max(
       (nextPollTime - Date.now()) / MS_IN_SECOND,
       MINIMUM_POLLING_PERIOD_SECONDS);
   updateCardsAttempts.start(nextPollDelaySeconds);
 }
 
 /**
+ * Merges stored notification groups into a set of Chrome notifications and
+ * shows them.
+ */
+function mergeAndShowNotificationCards() {
+  instrumented.storage.local.get('notificationGroups', function(items) {
+    console.log('mergeAndShowNotificationCards-get ' + JSON.stringify(items));
+    items = items || {};
+    items.notificationGroups = items.notificationGroups || {};
+
+    // Merge cards from all groups into one set.
+    var mergedCards = {};
+
+    for (var groupName in items.notificationGroups)
+      mergeGroup(mergedCards, items.notificationGroups[groupName]);
+
+    showNotificationCards(mergedCards);
+  });
+}
+
+/**
  * Parses JSON response from the notification server, shows notifications and
  * schedules next update.
  * @param {string} response Server response.
  */
 function parseAndShowNotificationCards(response) {
   console.log('parseAndShowNotificationCards ' + response);
   var parsedResponse = JSON.parse(response);
 
-  var groups = parsedResponse.groups;
+  var receivedGroups = parsedResponse.groups;
 
   // Populate groups with corresponding cards.
   if (parsedResponse.notifications) {
     for (var i = 0; i != parsedResponse.notifications.length; ++i) {
       var card = parsedResponse.notifications[i];
-      var group = groups[card.groupName];
+      var group = receivedGroups[card.groupName];
       group.cards = group.cards || [];
       group.cards.push(card);
     }
   }
 
   instrumented.storage.local.get('notificationGroups', function(items) {
     console.log('parseAndShowNotificationCards-get ' + JSON.stringify(items));
     items = items || {};
     items.notificationGroups = items.notificationGroups || {};
 
     var now = Date.now();
 
-    // Build updated set of groups and merge cards from all groups into one set.
-    var updatedGroups = {};
-    var mergedCards = {};
-
-    for (var groupName in groups) {
-      var receivedGroup = groups[groupName];
+    // Build updated set of groups.
+    for (var groupName in receivedGroups) {
+      var receivedGroup = receivedGroups[groupName];
       var storageGroup = items.notificationGroups[groupName] || {
         cards: [],
         cardsTimestamp: undefined,
         nextPollTime: now,
         rank: undefined
       };
 
       if (receivedGroup.requested)
         receivedGroup.cards = receivedGroup.cards || [];
 
       if (receivedGroup.cards) {
         storageGroup.cards = receivedGroup.cards;
         storageGroup.cardsTimestamp = now;
         storageGroup.rank = receivedGroup.rank;
       }
 
       if (receivedGroup.nextPollSeconds !== undefined) {
         storageGroup.nextPollTime =
             now + receivedGroup.nextPollSeconds * MS_IN_SECOND;
       }
 
-      updatedGroups[groupName] = storageGroup;
-
-      mergeGroup(mergedCards, storageGroup);
+      items.notificationGroups[groupName] = storageGroup;
     }
 
-    scheduleNextPoll(updatedGroups);
-
-    chrome.storage.local.set({notificationGroups: updatedGroups});
-
-    showNotificationCards(mergedCards);
+    scheduleNextPoll(items.notificationGroups);
+    chrome.storage.local.set({notificationGroups: items.notificationGroups});
+    mergeAndShowNotificationCards();

[robliao, 2013/10/14 21:05:31]

Seems like overkill to set notificationGroups and then immediately read it again
in this function.

A better way would be to abstract the get out of mergeAndShowNotificationCards
and have it accept a parameter that is simply the notificationGroups.

[vadimt, 2013/10/14 23:51:57]

I'd not do serious code refactorings, assuming that persistent notifications are
coming. And the perf benefit would be not noticeable, given that we do this only
once per Chrome's process life (per session).

[robliao, 2013/10/14 23:56:08]

This rearrangement only affects new code, namely mergeAndShowNotificationCards.

mergeAndShowNotificationCards can simply remove the get call and receive the
cards as an argument. 

On startup, you can add GetMergeAndShowNotificaitonCards that does the get step
and calls mergeAndShowNotificationCards.

This makes the startup path obvious that we're obtaining state and avoids the
whole set re-get code.

On 2013/10/14 23:51:57, vadimt wrote:

[vadimt, 2013/10/15 01:09:44]

Done.

+    recordEvent(GoogleNowEvent.CARDS_PARSE_SUCCESS);
   });
 }
 
 /**
  * Requests notification cards from the server.
  * @param {Location} position Location of this computer.
  */
 function requestNotificationCards(position) {
   console.log('requestNotificationCards ' + JSON.stringify(position) +
       ' from ' + NOTIFICATION_CARDS_URL);
@@ skipping 345 matching lines @@
   updateCardsAttempts.stop();
 
   removeAllCards();
 }
 
 /**
  * Initializes the event page on install or on browser startup.
  */
 function initialize() {
   recordEvent(GoogleNowEvent.EXTENSION_START);
-
-  // Alarms persist across chrome restarts. This is undesirable since it
-  // prevents us from starting up everything (alarms are a heuristic to
-  // determine if we are already running). To mitigate this, we will
-  // shut everything down on initialize before starting everything up.
-  stopPollingCards();
   onStateChange();
 }
 
 /**
  * Starts or stops the polling of cards.
  * @param {boolean} shouldPollCardsRequest true to start and
  *     false to stop polling cards.
  */
 function setShouldPollCards(shouldPollCardsRequest) {
   updateCardsAttempts.isRunning(function(currentValue) {
@@ skipping 183 matching lines @@
 
 instrumented.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     initialize();
   }
 });
 
 instrumented.runtime.onStartup.addListener(function() {
   console.log('onStartup');
+
+  // Show notifications received by earlier polls.
+  tasks.add(SHOW_ON_START_TASK_NAME, mergeAndShowNotificationCards);

[robliao, 2013/10/14 21:05:31]

This should occur after initialize.

[vadimt, 2013/10/14 23:51:57]

Why? Imagine that persistent notifications are implemented. Then, cards would be
restored very early, may be, before any JS code ran at all.

[robliao, 2013/10/14 23:56:08]

It is non-obvious to an outside reader why anything should occur before an
initialize step.
On 2013/10/14 23:51:57, vadimt wrote:

[vadimt, 2013/10/15 01:09:44]

Done.

+
   initialize();
 });
 
 instrumented.
     preferencesPrivate.
     googleGeolocationAccessEnabled.
     onChange.
     addListener(function(prefValue) {
       console.log('googleGeolocationAccessEnabled Pref onChange ' +
           prefValue.value);
@@ skipping 32 matching lines @@
 
 instrumented.location.onLocationUpdate.addListener(function(position) {
   recordEvent(GoogleNowEvent.LOCATION_UPDATE);
   updateNotificationsCards(position);
 });
 
 instrumented.omnibox.onInputEntered.addListener(function(text) {
   localStorage['server_url'] = NOTIFICATION_CARDS_URL = text;
   initialize();
 });