Combining cards instead of merging

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 84 matching lines @@
 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 ON_PUSH_MESSAGE_START_TASK_NAME = 'on-push-message';
 
 var LOCATION_WATCH_NAME = 'location-watch';
 
 /**
- * Notification as it's sent by the server.
+ * Group as received from the server.
  *
  * @typedef {{
- *   notificationId: string,
- *   chromeNotificationId: string,
- *   trigger: Object=,
- *   version: number,
- *   chromeNotificationOptions: Object,
- *   actionUrls: Object=,
- *   dismissal: Object
+ *   nextPollSeconds: (string|undefined),
+ *   rank: (number|undefined),
+ *   requested: (boolean|undefined)
  * }}
  */
-var UnmergedNotification;
+var ReceivedGroup;
+
+/**
+ * Server response with notifications and groups.
+ *
+ * @typedef {{
+ *   googleNowDisabled: (boolean|undefined),
+ *   groups: Object.<string, ReceivedGroup>,
+ *   notifications: Array.<ReceivedNotification>
+ * }}
+ */
+var ServerResponse;
 
 /**
  * Notification group as the client stores it. |cardsTimestamp| and |rank| are
  * defined if |cards| is non-empty. |nextPollTime| is undefined if the server
  * (1) never sent 'nextPollSeconds' for the group or
  * (2) didn't send 'nextPollSeconds' with the last group update containing a
  *     cards update and all the times after that.
  *
  * @typedef {{
- *   cards: Array.<UnmergedNotification>,
- *   cardsTimestamp: number=,
- *   nextPollTime: number=,
- *   rank: number=
+ *   cards: Array.<ReceivedNotification>,
+ *   cardsTimestamp: (number|undefined),
+ *   nextPollTime: (number|undefined),
+ *   rank: (number|undefined)
  * }}
  */
-var StorageGroup;
+var StoredNotificationGroup;
+
+/**
+ * Pending (not yet successfully sent) dismissal for a received notification.
+ * |time| is the moment when the user requested dismissal.
+ *
+ * @typedef {{
+ *   chromeNotificationId: ChromeNotificationId,
+ *   time: number,
+ *   dismissalData: DismissalData
+ * }}
+ */
+var PendingDismissal;
 
 /**
  * Checks if a new task can't be scheduled when another task is already
  * scheduled.
  * @param {string} newTaskName Name of the new task.
  * @param {string} scheduledTaskName Name of the scheduled task.
  * @return {boolean} Whether the new task conflicts with the existing task.
  */
 function areTasksConflicting(newTaskName, scheduledTaskName) {
   if (newTaskName == UPDATE_CARDS_TASK_NAME &&
@@ skipping 122 matching lines @@
       } else {
         originalOnLoadEnd(event);
       }
     });
 
     callbackBoolean(true);
   });
 }
 
 /**
- * Shows parsed and merged cards as notifications.
- * @param {Object.<string, MergedCard>} cards Map from chromeNotificationId to
- *     the merged card, containing cards to show.
- * @param {function(CardCreateInfo)=} onCardShown Optional parameter called when
- *     each card is shown.
+ * Shows parsed and combined cards as notifications.
+ * @param {Object.<ChromeNotificationId, CombinedCard>} cards Map from
+ *     chromeNotificationId to the combined card, containing cards to show.
+ * @param {function(ReceivedNotification)=} onCardShown Optional parameter
+ *     called when each card is shown.
  */
 function showNotificationCards(cards, onCardShown) {
   console.log('showNotificationCards ' + JSON.stringify(cards));
 
-  instrumented.storage.local.get(['notificationsData', 'recentDismissals'],
-      function(items) {
-        console.log('showNotificationCards-get ' +
-            JSON.stringify(items));
-        items = items || {};
-        items.notificationsData = items.notificationsData || {};
-        items.recentDismissals = items.recentDismissals || {};
+  instrumented.notifications.getAll(function(notifications) {
+    console.log('showNotificationCards-getAll ' +
+        JSON.stringify(notifications));
+    notifications = notifications || {};
 
-        instrumented.notifications.getAll(function(notifications) {
-          console.log('showNotificationCards-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] || [];
+    }
 
-          // Build a set of non-expired recent dismissals. It will be used for
-          // client-side filtering of cards.
-          var updatedRecentDismissals = {};
-          var currentTimeMs = Date.now();
-          for (var chromeNotificationId in items.recentDismissals) {
-            if (currentTimeMs - items.recentDismissals[chromeNotificationId] <
-                DISMISS_RETENTION_TIME_MS) {
-              updatedRecentDismissals[chromeNotificationId] =
-                  items.recentDismissals[chromeNotificationId];
-              delete cards[chromeNotificationId];
-            }
-          }
+    /** @type {Object.<string, NotificationDataEntry>} */
+    var notificationsData = {};
 
-          // Delete notifications that didn't receive an update.
-          for (var chromeNotificationId in notifications) {
-            console.log('showNotificationCards-delete-check ' +
-                        chromeNotificationId);
-            if (!(chromeNotificationId in cards)) {
-              console.log(
-                  'showNotificationCards-delete ' + chromeNotificationId);
-              cardSet.clear(chromeNotificationId, false);
-            }
-          }
-
-          // Create/update notifications and store their new properties.
-          var newNotificationsData = {};
-          for (var chromeNotificationId in cards) {
-            var notificationData =
-                items.notificationsData[chromeNotificationId];
-            var previousVersion = notifications[chromeNotificationId] &&
-                                  notificationData &&
-                                  notificationData.cardCreateInfo &&
-                                  notificationData.cardCreateInfo.version;
-            newNotificationsData[chromeNotificationId] = cardSet.update(
-                chromeNotificationId,
-                cards[chromeNotificationId],
-                previousVersion,
-                onCardShown);
-          }
-
-          chrome.storage.local.set({
-            notificationsData: newNotificationsData,
-            recentDismissals: updatedRecentDismissals
-          });
-        });
-      });
+    // Create/update/delete notifications.
+    for (var chromeNotificationId in cards) {
+      notificationsData[chromeNotificationId] = cardSet.update(
+          chromeNotificationId,
+          cards[chromeNotificationId],
+          onCardShown);
+    }
+    chrome.storage.local.set({notificationsData: notificationsData});
+  });
 }
 
 /**
  * Removes all cards and card state on Google Now close down.
  * For example, this occurs when the geolocation preference is unchecked in the
  * content settings.
  */
 function removeAllCards() {
   console.log('removeAllCards');
 
   // TODO(robliao): Once Google Now clears its own checkbox in the
   // notifications center and bug 260376 is fixed, the below clearing
   // code is no longer necessary.
   instrumented.notifications.getAll(function(notifications) {
     notifications = notifications || {};
     for (var chromeNotificationId in notifications) {
       instrumented.notifications.clear(chromeNotificationId, function() {});
     }
     chrome.storage.local.remove(['notificationsData', 'notificationGroups']);
   });
 }
 
 /**
- * Merges an unmerged notification into a merged card with same ID.
- * @param {MergedCard=} mergedCard Existing merged card or undefined if a merged
- *     card doesn't exist (i.e. we see this ID for the first time while
- *     merging).
- * @param {UnmergedNotification} unmergedNotification Notification as it was
- *     received from the server.
- * @param {number} notificationTimestamp The moment the unmerged card was
- *     received.
- * @param {number} notificationGroupRank Rank of the group of the unmerged card.
- * @return {MergedCard} Result of merging |unmergedNotification| into
- *     |mergedCard|.
+ * Adds a card group into a set of combined cards.
+ * @param {Object.<ChromeNotificationId, CombinedCard>} combinedCards Map from
+ *     chromeNotificationId to a combined card.
+ *     This is an input/output parameter.
+ * @param {StoredNotificationGroup} storedGroup Group to combine into the
+ *     combined card set.
  */
-function mergeCards(
-    mergedCard,
-    unmergedNotification,
-    notificationTimestamp,
-    notificationGroupRank) {
-  var result = mergedCard || {dismissals: []};
+function combineGroup(combinedCards, storedGroup) {
+  for (var i = 0; i < storedGroup.cards.length; i++) {
+    /** @type {ReceivedNotification} */
+    var receivedNotification = storedGroup.cards[i];
 
-  var priority = mergedCard ?
-      Math.max(
-          mergedCard.notification.priority,
-          unmergedNotification.chromeNotificationOptions.priority) :
-      unmergedNotification.chromeNotificationOptions.priority;
+    /** @type {UncombinedNotification} */
+    var uncombinedNotification = {
+      receivedNotification: receivedNotification,
+      showTime: receivedNotification.trigger.showTimeSec &&
+                (storedGroup.cardsTimestamp +
+                 receivedNotification.trigger.showTimeSec * MS_IN_SECOND),
+      hideTime: storedGroup.cardsTimestamp +
+                receivedNotification.trigger.hideTimeSec * MS_IN_SECOND
+    };
 
-  if (!mergedCard || notificationGroupRank > mergedCard.groupRank) {
-    result.groupRank = notificationGroupRank;
-    var showTime = unmergedNotification.trigger &&
-        unmergedNotification.trigger.showTimeSec &&
-        (notificationTimestamp +
-         unmergedNotification.trigger.showTimeSec * MS_IN_SECOND);
-    var hideTime = unmergedNotification.trigger &&
-        unmergedNotification.trigger.hideTimeSec &&
-        (notificationTimestamp +
-         unmergedNotification.trigger.hideTimeSec * MS_IN_SECOND);
-    result.trigger = {
-      showTime: showTime,
-      hideTime: hideTime
-    };
-  }
-
-  if (!mergedCard || notificationTimestamp > mergedCard.timestamp) {
-    result.timestamp = notificationTimestamp;
-    result.notification = unmergedNotification.chromeNotificationOptions;
-    result.actionUrls = unmergedNotification.actionUrls;
-    result.version = unmergedNotification.version;
-  }
-
-  result.locationBased =
-      result.locationBased || unmergedNotification.locationBased;
-
-  result.notification.priority = priority;
-  var dismissalData = {
-    notificationId: unmergedNotification.notificationId,
-    parameters: unmergedNotification.dismissal
-  };
-  result.dismissals.push(dismissalData);
-
-  return result;
-}
-
-/**
- * Merges a card group into a set of merged cards.
- * @param {Object.<string, MergedCard>} mergedCards Map from
- *     chromeNotificationId to a merged card.
- *     This is an input/output parameter.
- * @param {StorageGroup} storageGroup Group to merge into the merged card set.
- */
-function mergeGroup(mergedCards, storageGroup) {
-  for (var i = 0; i < storageGroup.cards.length; i++) {
-    var card = storageGroup.cards[i];
-    mergedCards[card.chromeNotificationId] = mergeCards(
-        mergedCards[card.chromeNotificationId],
-        card,
-        storageGroup.cardsTimestamp,
-        storageGroup.rank);
+    var combinedCard =
+        combinedCards[receivedNotification.chromeNotificationId] || [];
+    combinedCard.push(uncombinedNotification);
+    combinedCards[receivedNotification.chromeNotificationId] = combinedCard;
   }
 }
 
 /**
  * Schedules next cards poll.
- * @param {Object.<string, StorageGroup>} groups Map from group name to group
- *     information.
+ * @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;
 
     for (var groupName in groups) {
       var group = groups[groupName];
       if (group.nextPollTime !== undefined) {
         nextPollTime = nextPollTime == null ?
@@ skipping 13 matching lines @@
         'GoogleNow', function(params) {
       var optinPollPeriodSeconds =
           parseInt(params && params.optinPollPeriodSeconds, 10) ||
           DEFAULT_OPTIN_CHECK_PERIOD_SECONDS;
       updateCardsAttempts.start(optinPollPeriodSeconds);
     });
   }
 }
 
 /**
- * Merges notification groups into a set of Chrome notifications and shows them.
- * @param {Object.<string, StorageGroup>} notificationGroups Map from group name
- *     to group information.
- * @param {function(CardCreateInfo)=} onCardShown Optional parameter called when
- *     each card is shown.
+ * Combines notification groups into a set of Chrome notifications and shows
+ * them.
+ * @param {Object.<string, StoredNotificationGroup>} notificationGroups Map from
+ *     group name to group information.
+ * @param {function(ReceivedNotification)=} onCardShown Optional parameter
+ *     called when each card is shown.
  */
-function mergeAndShowNotificationCards(notificationGroups, onCardShown) {
-  var mergedCards = {};
+function combineAndShowNotificationCards(notificationGroups, onCardShown) {
+  console.log('combineAndShowNotificationCards ' +
+      JSON.stringify(notificationGroups));
+  /** @type {Object.<ChromeNotificationId, CombinedCard>} */
+  var combinedCards = {};
 
   for (var groupName in notificationGroups)
-    mergeGroup(mergedCards, notificationGroups[groupName]);
+    combineGroup(combinedCards, notificationGroups[groupName]);
 
-  showNotificationCards(mergedCards, onCardShown);
+  showNotificationCards(combinedCards, onCardShown);
 }
 
 /**
  * Parses JSON response from the notification server, shows notifications and
  * schedules next update.
  * @param {string} response Server response.
- * @param {function(CardCreateInfo)=} onCardShown Optional parameter called when
- *     each card is shown.
+ * @param {function(ReceivedNotification)=} onCardShown Optional parameter
+ *     called when each card is shown.
  */
 function parseAndShowNotificationCards(response, onCardShown) {
   console.log('parseAndShowNotificationCards ' + response);
+  /** @type {ServerResponse} */
   var parsedResponse = JSON.parse(response);
 
   if (parsedResponse.googleNowDisabled) {
     chrome.storage.local.set({googleNowEnabled: false});
     // TODO(vadimt): Remove the line below once the server stops sending groups
     // with 'googleNowDisabled' responses.
     parsedResponse.groups = {};
     // Google Now was enabled; now it's disabled. This is a state change.
     onStateChange();
   }
 
   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 = receivedGroups[card.groupName];
-      group.cards = group.cards || [];
-      group.cards.push(card);
-    }
-  }
-
-  instrumented.storage.local.get('notificationGroups', function(items) {
+  instrumented.storage.local.get(['notificationGroups', 'recentDismissals'],
+      function(items) {
     console.log('parseAndShowNotificationCards-get ' + JSON.stringify(items));

[robliao, 2013/12/07 00:51:29]

Style: These need to be tabbed over two spaces.

[vadimt, 2013/12/07 01:04:24]

Done.

     items = items || {};
+    /** @type {Object.<string, StoredNotificationGroup>} */
     items.notificationGroups = items.notificationGroups || {};
+    /** @type {Object.<NotificationId, number>} */
+    items.recentDismissals = items.recentDismissals || {};
 
+    // Build a set of non-expired recent dismissals. It will be used for
+    // client-side filtering of cards.
+    /** @type {Object.<NotificationId, number>} */
+    var updatedRecentDismissals = {};
     var now = Date.now();
+    for (var notificationId in items.recentDismissals) {
+      var dismissalAge = now - items.recentDismissals[notificationId];
+      if (dismissalAge < DISMISS_RETENTION_TIME_MS) {
+        updatedRecentDismissals[notificationId] =
+            items.recentDismissals[notificationId];
+      }
+    }
+
+    // Populate groups with corresponding cards.
+    if (parsedResponse.notifications) {
+      for (var i = 0; i < parsedResponse.notifications.length; ++i) {
+        /** @type {ReceivedNotification} */
+        var card = parsedResponse.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 = {};
 
     for (var groupName in receivedGroups) {
       var receivedGroup = receivedGroups[groupName];
-      var storageGroup = items.notificationGroups[groupName] || {
+      var storedGroup = items.notificationGroups[groupName] || {
         cards: [],
         cardsTimestamp: undefined,
         nextPollTime: undefined,
         rank: undefined
       };
 
       if (receivedGroup.requested)
         receivedGroup.cards = receivedGroup.cards || [];
 
       if (receivedGroup.cards) {
         // If the group contains a cards update, all its fields will get new
         // values.
-        storageGroup.cards = receivedGroup.cards;
-        storageGroup.cardsTimestamp = now;
-        storageGroup.rank = receivedGroup.rank;
-        storageGroup.nextPollTime = undefined;
+        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) {
-        storageGroup.nextPollTime =
+        storedGroup.nextPollTime =
             now + receivedGroup.nextPollSeconds * MS_IN_SECOND;
       }
 
-      updatedGroups[groupName] = storageGroup;
+      updatedGroups[groupName] = storedGroup;
     }
 
     scheduleNextPoll(updatedGroups, !parsedResponse.googleNowDisabled);
-    chrome.storage.local.set({notificationGroups: updatedGroups});
-    mergeAndShowNotificationCards(updatedGroups, onCardShown);
+    chrome.storage.local.set({
+      notificationGroups: updatedGroups,
+      recentDismissals: updatedRecentDismissals
+    });
+    combineAndShowNotificationCards(updatedGroups, onCardShown);
     recordEvent(GoogleNowEvent.CARDS_PARSE_SUCCESS);
   });
 }
 
 /**
  * Update Location Cards Shown Count.
- * @param {Object} cardCreateInfo Card Create Info
+ * @param {ReceivedNotification} receivedNotification Notification as it was
+ *     received from the server.
  */
-function countLocationCard(cardCreateInfo) {
-  if (cardCreateInfo.locationBased) {
+function countLocationCard(receivedNotification) {
+  if (receivedNotification.locationBased) {
     localStorage['locationCardsShown']++;
   }
 }
 
 /**
  * Requests notification cards from the server for specified groups.
  * @param {Array.<string>} groupNames Names of groups that need to be refreshed.
  */
 function requestNotificationGroups(groupNames) {
   console.log('requestNotificationGroups from ' + NOTIFICATION_CARDS_URL +
@@ skipping 15 matching lines @@
   });
 
   console.log('requestNotificationGroups: request=' + requestParameters);
 
   var request = buildServerRequest('GET', 'notifications' + requestParameters);
 
   request.onloadend = function(event) {
     console.log('requestNotificationGroups-onloadend ' + request.status);
     if (request.status == HTTP_OK) {
       recordEvent(GoogleNowEvent.REQUEST_FOR_CARDS_SUCCESS);
-      parseAndShowNotificationCards(request.response, cardShownCallback);
+      parseAndShowNotificationCards(request.responseText, cardShownCallback);
     }
   };
 
   setAuthorization(request, function(success) {
     if (success)
       request.send();
   });
 }
 
 /**
  * Requests the account opted-in state from the server.
  * @param {function()} optedInCallback Function that will be called if
  *     opted-in state is 'true'.
  */
 function requestOptedIn(optedInCallback) {
   console.log('requestOptedIn from ' + NOTIFICATION_CARDS_URL);
 
   var request = buildServerRequest('GET', 'settings/optin');
 
   request.onloadend = function(event) {
     console.log(
         'requestOptedIn-onloadend ' + request.status + ' ' + request.response);
     if (request.status == HTTP_OK) {
-      var parsedResponse = JSON.parse(request.response);
+      var parsedResponse = JSON.parse(request.responseText);
       if (parsedResponse.value) {
         chrome.storage.local.set({googleNowEnabled: true});
         optedInCallback();
         // Google Now was disabled, now it's enabled. This is a state change.
         onStateChange();
       } else {
         scheduleNextPoll({}, false);
       }
     }
   };
 
   setAuthorization(request, function(success) {
     if (success)
       request.send();
   });
 }
 
 /**
  * Requests notification cards from the server.
- * @param {Location} position Location of this computer.
+ * @param {Location=} position Location of this computer.
  */
 function requestNotificationCards(position) {
   console.log('requestNotificationCards ' + JSON.stringify(position));
 
   instrumented.storage.local.get(
       ['notificationGroups', 'googleNowEnabled'], function(items) {
     console.log('requestNotificationCards-storage-get ' +
                 JSON.stringify(items));
     items = items || {};
+    /** @type {Object.<string, StoredNotificationGroup>} */
+    items.notificationGroups = items.notificationGroups || {};
 
     var groupsToRequest = [];
 
-    if (items.notificationGroups) {
-      var now = Date.now();
+    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);
-      }
+    for (var groupName in items.notificationGroups) {
+      var group = items.notificationGroups[groupName];
+      if (group.nextPollTime !== undefined && group.nextPollTime <= now)
+        groupsToRequest.push(groupName);
     }
 
     if (items.googleNowEnabled) {
       requestNotificationGroups(groupsToRequest);
     } else {
       requestOptedIn(function() {
         requestNotificationGroups(groupsToRequest);
       });
     }
   });
@@ skipping 31 matching lines @@
  * Stops getting the location.
  */
 function stopRequestLocation() {
   console.log('stopRequestLocation');
   chrome.location.clearWatch(LOCATION_WATCH_NAME);
 }
 
 /**
  * Obtains new location; requests and shows notification cards based on this
  * location.
- * @param {Location} position Location of this computer.
+ * @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() {
     console.log('updateNotificationsCards-task-begin');
     updateCardsAttempts.isRunning(function(running) {
       if (running) {
         updateCardsAttempts.planForNext(function() {
           processPendingDismissals(function(success) {
             if (success) {
               // The cards are requested only if there are no unsent dismissals.
               requestNotificationCards(position);
             }
           });
         });
       }
     });
   });
 }
 
 /**
  * Sends a server request to dismiss a card.
- * @param {string} chromeNotificationId chrome.notifications ID of the 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.
  * @param {function(boolean)} callbackBoolean Completion callback with 'done'
  *     parameter.
  */
 function requestCardDismissal(
     chromeNotificationId, dismissalTimeMs, dismissalData, callbackBoolean) {
-  console.log('requestDismissingCard ' + chromeNotificationId + ' from ' +
-      NOTIFICATION_CARDS_URL);
+  console.log('requestDismissingCard ' + chromeNotificationId +
+      ' from ' + NOTIFICATION_CARDS_URL +
+      ', dismissalData=' + JSON.stringify(dismissalData));
 
   var dismissalAge = Date.now() - dismissalTimeMs;
 
   if (dismissalAge > MAXIMUM_DISMISSAL_AGE_MS) {
     callbackBoolean(true);
     return;
   }
 
   recordEvent(GoogleNowEvent.DISMISS_REQUEST_TOTAL);
 
-  var request = 'notifications/' + dismissalData.notificationId +
+  var requestParameters = 'notifications/' + dismissalData.notificationId +
       '?age=' + dismissalAge +
       '&chromeNotificationId=' + chromeNotificationId;
 
   for (var paramField in dismissalData.parameters)
-    request += ('&' + paramField + '=' + dismissalData.parameters[paramField]);
+    requestParameters += ('&' + paramField +
+    '=' + dismissalData.parameters[paramField]);
 
-  console.log('requestCardDismissal: request=' + request);
+  console.log('requestCardDismissal: requestParameters=' + requestParameters);
 
-  var request = buildServerRequest('DELETE', request);
+  var request = buildServerRequest('DELETE', requestParameters);
   request.onloadend = function(event) {
     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.
     var done = request.status == HTTP_NOCONTENT ||
         request.status == HTTP_BAD_REQUEST ||
         request.status == HTTP_METHOD_NOT_ALLOWED;
@@ skipping 12 matching lines @@
  * Tries to send dismiss requests for all pending dismissals.
  * @param {function(boolean)} callbackBoolean Completion callback with 'success'
  *     parameter. Success means that no pending dismissals are left.
  */
 function processPendingDismissals(callbackBoolean) {
   instrumented.storage.local.get(['pendingDismissals', 'recentDismissals'],
       function(items) {
         console.log('processPendingDismissals-storage-get ' +
                     JSON.stringify(items));
         items = items || {};
+        /** @type {Array.<PendingDismissal>} */
         items.pendingDismissals = items.pendingDismissals || [];
+        /** @type {Object.<NotificationId, number>} */
         items.recentDismissals = items.recentDismissals || {};
 
         var dismissalsChanged = false;
 
         function onFinish(success) {
           if (dismissalsChanged) {
             chrome.storage.local.set({
               pendingDismissals: items.pendingDismissals,
               recentDismissals: items.recentDismissals
             });
           }
           callbackBoolean(success);
         }
 
         function doProcessDismissals() {
           if (items.pendingDismissals.length == 0) {
             dismissalAttempts.stop();
             onFinish(true);
             return;
           }
 
           // Send dismissal for the first card, and if successful, repeat
           // recursively with the rest.
+          /** @type {PendingDismissal} */
           var dismissal = items.pendingDismissals[0];
           requestCardDismissal(
               dismissal.chromeNotificationId,
               dismissal.time,
               dismissal.dismissalData,
               function(done) {
                 if (done) {
                   dismissalsChanged = true;
                   items.pendingDismissals.splice(0, 1);
-                  items.recentDismissals[dismissal.chromeNotificationId] =
+                  items.recentDismissals[
+                      dismissal.dismissalData.notificationId] =
                       Date.now();
                   doProcessDismissals();
                 } else {
                   onFinish(false);
                 }
               });
         }
 
         doProcessDismissals();
       });
@@ skipping 18 matching lines @@
   instrumented.tabs.create({url: url}, function(tab) {
     if (tab)
       chrome.windows.update(tab.windowId, {focused: true});
     else
       chrome.windows.create({url: url, focused: true});
   });
 }
 
 /**
  * Opens URL corresponding to the clicked part of the notification.
- * @param {string} chromeNotificationId chrome.notifications ID of the card.
- * @param {function(Object): string} selector Function that extracts the url for
- *     the clicked area from the button action URLs info.
+ * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
+ *     the card.
+ * @param {function((ActionUrls|undefined)): (string|undefined)} selector
+ *     Function that extracts the url for the clicked area from the button
+ *     action URLs info.
  */
 function onNotificationClicked(chromeNotificationId, selector) {
   instrumented.storage.local.get('notificationsData', function(items) {
+    /** @type {(NotificationDataEntry|undefined)} */
     var notificationData = items &&
         items.notificationsData &&
         items.notificationsData[chromeNotificationId];
 
     if (!notificationData)
       return;
 
     var url = selector(notificationData.actionUrls);
     if (!url)
       return;
 
     openUrl(url);
   });
 }
 
 /**
  * Callback for chrome.notifications.onClosed event.
- * @param {string} chromeNotificationId chrome.notifications ID of the card.
+ * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
+ *     the card.
  * @param {boolean} byUser Whether the notification was closed by the user.
  */
 function onNotificationClosed(chromeNotificationId, byUser) {
   if (!byUser)
     return;
 
   // At this point we are guaranteed that the notification is a now card.
   chrome.metricsPrivate.recordUserAction('GoogleNow.Dismissed');
 
   tasks.add(DISMISS_CARD_TASK_NAME, function() {
     dismissalAttempts.start();
 
     instrumented.storage.local.get(
         ['pendingDismissals', 'notificationsData'], function(items) {
       items = items || {};
+      /** @type {Array.<PendingDismissal>} */
       items.pendingDismissals = items.pendingDismissals || [];
+      /** @type {Object.<string, NotificationDataEntry>} */
       items.notificationsData = items.notificationsData || {};
 
-      // Deleting the notification in case it was re-added while this task was
-      // scheduled, waiting for execution; also cleaning notification's data
-      // from storage.
-      cardSet.clear(chromeNotificationId, true);
+      /** @type {NotificationDataEntry} */
+      var notificationData = items.notificationsData[chromeNotificationId] || {
+        timestamp: Date.now(),
+        combinedCard: []
+      };
 
-      var notificationData = items.notificationsData[chromeNotificationId];
+      var dismissalResult =
+          cardSet.onDismissal(chromeNotificationId, notificationData);
 
-      if (notificationData && notificationData.dismissals) {
-        for (var i = 0; i < notificationData.dismissals.length; i++) {
-          var dismissal = {
-            chromeNotificationId: chromeNotificationId,
-            time: Date.now(),
-            dismissalData: notificationData.dismissals[i]
-          };
-          items.pendingDismissals.push(dismissal);
-        }
+      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);
+      }
 
-        chrome.storage.local.set({pendingDismissals: items.pendingDismissals});
-      }
+      items.notificationsData[chromeNotificationId] =
+          dismissalResult.notificationData;
+
+      chrome.storage.local.set({
+        pendingDismissals: items.pendingDismissals,
+        notificationsData: items.notificationsData
+      });
 
       processPendingDismissals(function(success) {});
     });
   });
 }
 
 /**
  * Initializes the polling system to start monitoring location and fetching
  * cards.
  */
@@ skipping 164 matching lines @@
 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 || {};
+      /** @type {Object.<string, StoredNotificationGroup>} */
       items.notificationGroups = items.notificationGroups || {};
 
-      mergeAndShowNotificationCards(items.notificationGroups);
+      combineAndShowNotificationCards(items.notificationGroups);
     });
   });
 
   initialize();
 });
 
 instrumented.
     preferencesPrivate.
     googleGeolocationAccessEnabled.
     onChange.
@@ skipping 15 matching lines @@
         return actionUrls && actionUrls.messageUrl;
       });
     });
 
 instrumented.notifications.onButtonClicked.addListener(
     function(chromeNotificationId, buttonIndex) {
       chrome.metricsPrivate.recordUserAction(
           'GoogleNow.ButtonClicked' + buttonIndex);
       onNotificationClicked(chromeNotificationId, function(actionUrls) {
         var url = actionUrls.buttonUrls[buttonIndex];
-        verify(url, 'onButtonClicked: no url for a button');
+        verify(url !== undefined, 'onButtonClicked: no url for a button');
         return url;
       });
     });
 
 instrumented.notifications.onClosed.addListener(onNotificationClosed);
 
 instrumented.notifications.onPermissionLevelChanged.addListener(
     function(permissionLevel) {
       console.log('Notifications permissionLevel Change');
       onStateChange();
@@ skipping 23 matching lines @@
         if (!items)
           return;
 
         // If this is the first time we get lastPollNowPayloads, initialize it.
         items.lastPollNowPayloads = items.lastPollNowPayloads || {};
 
         if (items.lastPollNowPayloads[message.subchannelId] !=
             message.payload) {
           items.lastPollNowPayloads[message.subchannelId] = message.payload;
 
+          /** @type {Object.<string, StoredNotificationGroup>} */
           items.notificationGroups = items.notificationGroups || {};
           items.notificationGroups['PUSH' + message.subchannelId] = {
             cards: [],
             nextPollTime: Date.now()
           };
 
           chrome.storage.local.set({
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
           updateNotificationsCards();
         }
       });
     });
   }
 });