Switching getting/dismissing cards to new protocol

chrome/browser/resources/google_now/cards.js

 // Copyright 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';
 
-var MS_IN_SECOND = 1000;
+/**
+ * Show/hide trigger in a card.
+ *
+ * @typedef {{
+ *   showTime: number=,
+ *   hideTime: number=
+ * }}
+ */
+var Trigger;
+
+/**
+ * Data to build a dismissal request for a card from a specific group.
+ *
+ * @typedef {{
+ *   notificationId: string,
+ *   parameters: Object
+ * }}
+ */
+var DismissalData;
+
+/**
+ * Card merged from potentially multiple groups.
+ *
+ * @typedef {{
+ *   trigger: Trigger,
+ *   version: number,
+ *   timestamp: number,
+ *   notification: Object,
+ *   actionUrls: Object,
+ *   groupRank: number,
+ *   dismissals: Array.<DismissalData>
+ * }}
+ */
+var MergedCard;
+
+/**
+ * Set of parameters for creating card notification.
+ *
+ * @typedef {{
+ *   notification: Object,
+ *   hideTime: number=,
+ *   version: number,
+ *   previousVersion: number=
+ * }}
+ */
+var CardCreateInfo;
 
 /**
  * Builds an object to manage notification card set.
  * @return {Object} Card set interface.
  */
 function buildCardSet() {
   var cardShowPrefix = 'card-show-';
   var cardHidePrefix = 'card-hide-';
 
   /**
    * Schedules hiding a notification.
    * @param {string} cardId Card ID.
    * @param {number=} opt_timeHide If specified, epoch time to hide the card. If
    *      undefined, the card will be kept shown at least until next update.
    */
   function scheduleHiding(cardId, opt_timeHide) {
     if (opt_timeHide === undefined)
       return;
 
     var alarmName = cardHidePrefix + cardId;
     var alarmInfo = {when: opt_timeHide};
     chrome.alarms.create(alarmName, alarmInfo);
   }
 
   /**
    * Shows a notification.
    * @param {string} cardId Card ID.
-   * @param {Object} cardCreateInfo Google Now card represented as a set of
-   *     parameters for showing a Chrome notification.
+   * @param {CardCreateInfo} cardCreateInfo Google Now card represented as a set
+   *     of parameters for showing a Chrome notification.
    */
   function showNotification(cardId, cardCreateInfo) {
     console.log('cardManager.showNotification ' + cardId + ' ' +
                 JSON.stringify(cardCreateInfo));
 
     if (cardCreateInfo.previousVersion !== cardCreateInfo.version) {
       // Delete a notification with the specified id if it already exists, and
       // then create a notification.
       instrumented.notifications.create(
           cardId,
           cardCreateInfo.notification,
           function(newNotificationId) {
             if (!newNotificationId || chrome.runtime.lastError) {
               var errorMessage = chrome.runtime.lastError &&
                                   chrome.runtime.lastError.message;
               console.error('notifications.create: ID=' + newNotificationId +
                             ', ERROR=' + errorMessage);
               return;
             }
 
-            scheduleHiding(cardId, cardCreateInfo.timeHide);
+              scheduleHiding(cardId, cardCreateInfo.hideTime);
           });
     } else {
       // Update existing notification.
       instrumented.notifications.update(
           cardId,
           cardCreateInfo.notification,
           function(wasUpdated) {
             if (!wasUpdated || chrome.runtime.lastError) {
               var errorMessage = chrome.runtime.lastError &&
                                   chrome.runtime.lastError.message;
               console.error('notifications.update: UPDATED=' + wasUpdated +
                             ', ERROR=' + errorMessage);
               return;
             }
 
-            scheduleHiding(cardId, cardCreateInfo.timeHide);
+              scheduleHiding(cardId, cardCreateInfo.hideTime);
           });
     }
   }
 
   /**
    * Updates/creates a card notification with new data.
-   * @param {Object} card Google Now from the server.
+   * @param {string} cardId Card ID.
+   * @param {MergedCard} card Google Now from the server.

[rgustafson, 2013/09/30 21:26:09]

Google Now card?

[vadimt, 2013/09/30 22:10:39]

Done.

    * @param {number=} previousVersion The version of the shown card with
    *     this id, if it exists, undefined otherwise.
    * @return {Object} Notification data entry for this card.
    */
-  function update(card, previousVersion) {
+  function update(cardId, card, previousVersion) {
     console.log('cardManager.update ' + JSON.stringify(card) + ' ' +
         previousVersion);
 
-    if (typeof card.version != 'number') {
-      console.log('cardCreateInfo.version is not a number');
-      // Fix card version.
-      card.version = previousVersion || 0;
-    }
-
     // TODO(vadimt): Don't clear alarms etc that don't exist. Or make sure doing
     // this doesn't output an error to console.
-    chrome.alarms.clear(cardHidePrefix + card.notificationId);
+    chrome.alarms.clear(cardHidePrefix + cardId);
 
-    var timeHide = card.trigger && card.trigger.hideTimeSec !== undefined ?
-        Date.now() + card.trigger.hideTimeSec * MS_IN_SECOND : undefined;
     var cardCreateInfo = {
       notification: card.notification,
-      timeHide: timeHide,
+      hideTime: card.trigger.hideTime,
       version: card.version,
       previousVersion: previousVersion
     };
 
-    var cardShowAlarmName = cardShowPrefix + card.notificationId;
-    if (card.trigger && card.trigger.showTimeSec) {
+    var cardShowAlarmName = cardShowPrefix + cardId;
+    if (card.trigger.showTime && card.trigger.showTime > Date.now()) {
       // Card needs to be shown later.
-      console.log('cardManager.register: postponed');
+      console.log('cardManager.update: postponed');
       var alarmInfo = {
-        when: Date.now() + card.trigger.showTimeSec * MS_IN_SECOND
+        when: card.trigger.showTime
       };
       chrome.alarms.create(cardShowAlarmName, alarmInfo);
     } else {
       // Card needs to be shown immediately.
-      console.log('cardManager.register: immediate');
+      console.log('cardManager.update: immediate');
       chrome.alarms.clear(cardShowAlarmName);
-      showNotification(card.notificationId, cardCreateInfo);
+      showNotification(cardId, cardCreateInfo);
     }
 
     return {
       actionUrls: card.actionUrls,
       cardCreateInfo: cardCreateInfo,
-      dismissalParameters: card.dismissal
+      dismissals: card.dismissals
     };
   }
 
   /**
    * Removes a card notification.
    * @param {string} cardId Card ID.
    */
   function clear(cardId) {
-    console.log('cardManager.unregister ' + cardId);
+    console.log('cardManager.clear ' + cardId);
 
     chrome.notifications.clear(cardId, function() {});
     chrome.alarms.clear(cardShowPrefix + cardId);
     chrome.alarms.clear(cardHidePrefix + cardId);
   }
 
   instrumented.alarms.onAlarm.addListener(function(alarm) {
     console.log('cardManager.onAlarm ' + JSON.stringify(alarm));
 
     if (alarm.name.indexOf(cardShowPrefix) == 0) {
       // Alarm to show the card.
       var cardId = alarm.name.substring(cardShowPrefix.length);
       instrumented.storage.local.get('notificationsData', function(items) {
         console.log('cardManager.onAlarm.get ' + JSON.stringify(items));
         if (!items || !items.notificationsData)
           return;
         var notificationData = items.notificationsData[cardId];
         if (!notificationData)
           return;
 
         showNotification(cardId, notificationData.cardCreateInfo);
       });
     } else if (alarm.name.indexOf(cardHidePrefix) == 0) {
       // Alarm to hide the card.
       var cardId = alarm.name.substring(cardHidePrefix.length);
-      chrome.notifications.clear(cardId, function() {});
+      clear(cardId);
     }
   });
 
   return {
     update: update,
     clear: clear
   };
 }