Shorten Closure template notation from Array.<*> to Array<*>.

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 107 matching lines @@
  *   requested: (boolean|undefined)
  * }}
  */
 var ReceivedGroup;
 
 /**
  * Server response with notifications and groups.
  *
  * @typedef {{
  *   googleNowDisabled: (boolean|undefined),
- *   groups: Object.<string, ReceivedGroup>,
- *   notifications: Array.<ReceivedNotification>
+ *   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.<ReceivedNotification>,
+ *   cards: Array<ReceivedNotification>,
  *   cardsTimestamp: (number|undefined),
  *   nextPollTime: (number|undefined),
  *   rank: (number|undefined)
  * }}
  */
 var StoredNotificationGroup;
 
 /**
  * Pending (not yet successfully sent) dismissal for a received notification.
  * |time| is the moment when the user requested dismissal.
@@ skipping 182 matching lines @@
       }, false);
       request.send();
     });
     requestPromise.catch(checkAuthenticationStatus(token));
     return requestPromise;
   });
 }
 
 /**
  * Shows the notification groups as notification cards.
- * @param {Object.<string, StoredNotificationGroup>} notificationGroups Map from
+ * @param {Object<string, StoredNotificationGroup>} notificationGroups Map from
  *     group name to group information.
  * @param {function(ReceivedNotification)=} opt_onCardShown Optional parameter
  *     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>} */
+  /** @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));
       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>} */
+      /** @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);
       }
@@ skipping 16 matching lines @@
     notifications = notifications || {};
     for (var chromeNotificationId in notifications) {
       instrumented.notifications.clear(chromeNotificationId, function() {});
     }
     chrome.storage.local.remove(['notificationsData', 'notificationGroups']);
   });
 }
 
 /**
  * Adds a card group into a set of combined cards.
- * @param {Object.<ChromeNotificationId, CombinedCard>} combinedCards Map from
+ * @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 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),
       hideTime: storedGroup.cardsTimestamp +
                 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.<string, StoredNotificationGroup>} groups Map from group name
+ * @param {Object<string, 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);
     }
   }
 
   // At least one of the groups must have nextPollTime.
   verify(nextPollTime != null, 'calculateNextPollTime: nextPollTime is null');
   return nextPollTime;
 }
 
 /**
  * Schedules next cards poll.
- * @param {Object.<string, StoredNotificationGroup>} groups Map from group name
+ * @param {Object<string, 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) {
     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.<string, StoredNotificationGroup>} notificationGroups Map from
+ * @param {Object<string, StoredNotificationGroup>} notificationGroups Map from
  *     group name to group information.
- * @return {Object.<ChromeNotificationId, CombinedCard>} Cards to show.
+ * @return {Object<ChromeNotificationId, CombinedCard>} Cards to show.
  */
 function combineCardsFromGroups(notificationGroups) {
   console.log('combineCardsFromGroups ' + JSON.stringify(notificationGroups));
-  /** @type {Object.<ChromeNotificationId, CombinedCard>} */
+  /** @type {Object<ChromeNotificationId, CombinedCard>} */
   var combinedCards = {};
 
   for (var groupName in notificationGroups)
     combineGroup(combinedCards, notificationGroups[groupName]);
 
   return combinedCards;
 }
 
 /**
  * Processes a server response for consumption by showNotificationGroups.
  * @param {ServerResponse} response Server response.
  * @return {Promise} A promise to process the server response and provide
  *     updated groups. Rejects if the server response shouldn't be processed.
  */
 function processServerResponse(response) {
   console.log('processServerResponse ' + JSON.stringify(response));
 
   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.<string, StoredNotificationGroup>} */
+    /** @type {Object<string, StoredNotificationGroup>} */
     notificationGroups: {},
-    /** @type {Object.<ServerNotificationId, number>} */
+    /** @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>} */
+    /** @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];
       }
     }
 
@@ skipping 68 matching lines @@
  * @return {boolean} true if an explanatory card should be shown.
  */
 function shouldShowExplanatoryCard() {
   var isBelowThreshold =
       localStorage['explanatoryCardsShown'] < EXPLANATORY_CARDS_LINK_THRESHOLD;
   return isBelowThreshold;
 }
 
 /**
  * Requests notification cards from the server for specified groups.
- * @param {Array.<string>} groupNames Names of groups that need to be refreshed.
+ * @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=' +
@@ skipping 61 matching lines @@
     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.<string, StoredNotificationGroup>} */
+    /** @type {Object<string, 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);
@@ skipping 24 matching lines @@
               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.
+ * @param {Array<string>} groupNames Names of groups that need to be refreshed.
  * @return {boolean} Whether a retry should occur.
  */
 function shouldScheduleRetryFromGroupList(groupNames) {
   return (groupNames.length != 1) || (groupNames[0] !== 'NOR');
 }
 
 /**
  * Requests and shows notification cards.
  */
 function requestCards() {
@@ skipping 73 matching lines @@
   });
 }
 
 /**
  * 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>} */
+    /** @type {Array<PendingDismissal>} */
     pendingDismissals: [],
-    /** @type {Object.<ServerNotificationId, number>} */
+    /** @type {Object<ServerNotificationId, number>} */
     recentDismissals: {}
   }).then(function(items) {
     console.log(
         'processPendingDismissals-storage-get ' + JSON.stringify(items));
 
     var dismissalsChanged = false;
 
     function onFinish(success) {
       if (dismissalsChanged) {
         chrome.storage.local.set({
@@ skipping 57 matching lines @@
 /**
  * Opens URL corresponding to the clicked part of the notification.
  * @param {ChromeNotificationId} chromeNotificationId chrome.notifications ID of
  *     the card.
  * @param {function(NotificationDataEntry): (string|undefined)} selector
  *     Function that extracts the url for the clicked area from the
  *     notification data entry.
  */
 function onNotificationClicked(chromeNotificationId, selector) {
   fillFromChromeLocalStorage({
-    /** @type {Object.<ChromeNotificationId, NotificationDataEntry>} */
+    /** @type {Object<ChromeNotificationId, NotificationDataEntry>} */
     notificationsData: {}
   }).then(function(items) {
     /** @type {(NotificationDataEntry|undefined)} */
     var notificationDataEntry = items.notificationsData[chromeNotificationId];
     if (!notificationDataEntry)
       return;
 
     var url = selector(notificationDataEntry);
     if (!url)
       return;
@@ skipping 12 matching lines @@
   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();
 
     fillFromChromeLocalStorage({
-      /** @type {Array.<PendingDismissal>} */
+      /** @type {Array<PendingDismissal>} */
       pendingDismissals: [],
-      /** @type {Object.<ChromeNotificationId, NotificationDataEntry>} */
+      /** @type {Object<ChromeNotificationId, NotificationDataEntry>} */
       notificationsData: {},
-      /** @type {Object.<string, StoredNotificationGroup>} */
+      /** @type {Object<string, StoredNotificationGroup>} */
       notificationGroups: {}
     }).then(function(items) {
       /** @type {NotificationDataEntry} */
       var notificationData =
           items.notificationsData[chromeNotificationId] ||
           {
             timestamp: Date.now(),
             combinedCard: []
           };
 
@@ skipping 287 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() {
     fillFromChromeLocalStorage({
-      /** @type {Object.<string, StoredNotificationGroup>} */
+      /** @type {Object<string, StoredNotificationGroup>} */
       notificationGroups: {}
     }).then(function(items) {
       console.log('onStartup-get ' + JSON.stringify(items));
 
       showNotificationGroups(items.notificationGroups).then(function() {
         chrome.storage.local.set(items);
       });
     });
   });
 
@@ skipping 67 matching lines @@
   // Each time after signing in, we'll get latest payload for all channels.
   // So, we need to poll the server only when the payload is non-empty and has
   // changed.
   console.log('pushMessaging.onMessage ' + JSON.stringify(message));
   if (message.payload.indexOf('REQUEST_CARDS') == 0) {
     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.<string, StoredNotificationGroup>} */
+        /** @type {Object<string, StoredNotificationGroup>} */
         notificationGroups: {}
       }, PromiseRejection.ALLOW).then(function(items) {
         if (items.lastPollNowPayloads[message.subchannelId] !=
             message.payload) {
           items.lastPollNowPayloads[message.subchannelId] = message.payload;
 
           items.notificationGroups['PUSH' + message.subchannelId] = {
             cards: [],
             nextPollTime: Date.now()
           };
 
           chrome.storage.local.set({
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
           pollOptedInWithRecheck();
         }
       });
     });
   }
 });