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 notification groups into a set of Chrome notifications and shows them.
+ * @param {Object.<string, StorageGroup>} notificationGroups Map from group name
+ *     to group information.
+ */
+function mergeAndShowNotificationCards(notificationGroups) {
+  // Merge cards from all groups into one set.

[rgustafson, 2013/10/15 21:14:33]

nit: comment not really necessary. If you want more detail, put it in the
function comment since this is describing the whole function minus
showNotificationCards which is self explanatory.

[vadimt, 2013/10/15 21:28:03]

Done.

+  var mergedCards = {};
+
+  for (var groupName in notificationGroups)
+    mergeGroup(mergedCards, 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 = {};

[rgustafson, 2013/10/15 21:14:33]

For updatedGroups -> items.notificationGroups

What if a group disappears? 

[vadimt, 2013/10/15 21:28:03]

Ah, looks like I forgot the protocol...
So, the server will send all existing groups, always, correct?

[rgustafson, 2013/10/15 21:43:41]

This is the joy of having extensibility which there are no plans to use. :) With
the existing server implementation, all groups will always be sent so this would
be fine. If we were to add more groups with more specific requests, those would
likely only exist for the lifetime of one notification or less. There is a less
than one percent chance imo of another group being made which behaves in the
exact same way as the existing groups; new groups would be transient. It's up to
you how far you want to go with making this extensible since I really do not see
this being used any time soon.

[vadimt, 2013/10/15 22:05:36]

Thanks; you've found a regression; I'm fixing it.

-    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(items.notificationGroups);
+    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. Doing this as early as
+  // possible to reduce latency of showing first notifications. This mimics how
+  // persistent notifications will work.
+  tasks.add(SHOW_ON_START_TASK_NAME, function() {
+    instrumented.storage.local.get('notificationGroups', function(items) {
+      console.log('onStartup-get ' + JSON.stringify(items));
+      items = items || {};
+      items.notificationGroups = items.notificationGroups || {};
+
+      mergeAndShowNotificationCards(items.notificationGroups);
+    });
+  });
+
   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();
 });