Convert now component to use GCM rather than pushMessaging.

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 77 matching lines @@
  */
 var DEFAULT_OPTIN_CHECK_PERIOD_SECONDS = 60 * 60 * 24 * 7; // 1 week
 
 /**
  * URL to open when the user clicked on a link for the our notification
  * settings.
  */
 var SETTINGS_URL = 'https://support.google.com/chrome/?p=ib_google_now_welcome';
 
 /**
+ * GCM registration URL.
+ */
+var GCM_REGISTRATION_URL =
+    'https://android.googleapis.com/gcm/googlenotification';
+
+/**
+ * DevConsole project ID for GCM API use.
+ */
+var GCM_PROJECT_ID = '437902709571';
+
+/**
  * Number of cards that need an explanatory link.
  */
 var EXPLANATORY_CARDS_LINK_THRESHOLD = 4;
 
 /**
  * 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';
@@ skipping 74 matching lines @@
     // send dismissals is scheduled.
     return true;
   }
 
   return false;
 }
 
 var tasks = buildTaskManager(areTasksConflicting);
 
 // Add error processing to API calls.
+wrapper.instrumentChromeApiFunction('gcm.onMessage.addListener', 0);
+wrapper.instrumentChromeApiFunction('gcm.register', 1);
 wrapper.instrumentChromeApiFunction('metricsPrivate.getVariationParams', 1);
 wrapper.instrumentChromeApiFunction('notifications.clear', 1);
 wrapper.instrumentChromeApiFunction('notifications.create', 2);
 wrapper.instrumentChromeApiFunction('notifications.getPermissionLevel', 0);
 wrapper.instrumentChromeApiFunction('notifications.update', 2);
 wrapper.instrumentChromeApiFunction('notifications.getAll', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onButtonClicked.addListener', 0);
 wrapper.instrumentChromeApiFunction('notifications.onClicked.addListener', 0);
 wrapper.instrumentChromeApiFunction('notifications.onClosed.addListener', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onPermissionLevelChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction(
     'notifications.onShowSettings.addListener', 0);
 wrapper.instrumentChromeApiFunction('permissions.contains', 1);
-wrapper.instrumentChromeApiFunction('pushMessaging.onMessage.addListener', 0);
-wrapper.instrumentChromeApiFunction('storage.onChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction('runtime.onInstalled.addListener', 0);
 wrapper.instrumentChromeApiFunction('runtime.onStartup.addListener', 0);
+wrapper.instrumentChromeApiFunction('storage.onChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction('tabs.create', 1);
 
 var updateCardsAttempts = buildAttemptManager(
     'cards-update',
     requestCards,
     INITIAL_POLLING_PERIOD_SECONDS,
     MAXIMUM_POLLING_PERIOD_SECONDS);
 var optInPollAttempts = buildAttemptManager(
     'optin',
     pollOptedInNoImmediateRecheck,
@@ skipping 787 matching lines @@
   // We don't clear localStorage since those values are still relevant
   // across Google Now start-stop events.
   chrome.storage.local.clear();
 }
 
 /**
  * Initializes the event page on install or on browser startup.
  */
 function initialize() {
   recordEvent(GoogleNowEvent.EXTENSION_START);
+  registerForGcm();
   onStateChange();
 }
 
 /**
  * Starts or stops the main pipeline for polling cards.
  * @param {boolean} shouldPollCardsRequest true to start and
  *     false to stop polling cards.
  */
 function setShouldPollCards(shouldPollCardsRequest) {
   updateCardsAttempts.isRunning(function(currentValue) {
@@ skipping 169 matching lines @@
  *     opt-in state.
  */
 function isGoogleNowEnabled() {
   return fillFromChromeLocalStorage({googleNowEnabled: false})
       .then(function(items) {
         return items.googleNowEnabled;
       });
 }
 
 /**
+ * Ensures the extension is ready to listen for GCM messages.
+ */
+function registerForGcm() {
+  // We don't need to use the key yet, just ensure the channel is set up.
+  getGcmNotificationKey();
+}
+
+/**
+ * Returns a Promise resolving to either a cached or new GCM notification key.
+ * Rejects if registration fails.
+ * @return {Promise} A Promise that resolves to a potentially-cached GCM key.
+ */
+function getGcmNotificationKey() {
+  return fillFromChromeLocalStorage({gcmNotificationKey: undefined})
+      .then(function(items) {
+        if (items.gcmNotificationKey) {
+          console.log('Reused gcm key from storage.');
+          return Promise.resolve(items.gcmNotificationKey);
+        }
+        return requestNewGcmNotificationKey();
+      });
+}
+
+/**
+ * Returns a promise resolving to a GCM Notificaiton Key. May call
+ * chrome.gcm.register() first if required. Rejects on registration failure.
+ * @return {Promise} A Promise that resolves to a fresh GCM Notification key.
+ */
+function requestNewGcmNotificationKey() {
+  return getGcmRegistrationId().then(function(gcmId) {
+    authenticationManager.getAuthToken().then(function(token) {
+      authenticationManager.getLogin().then(function(username) {
+        return new Promise(function(resolve, reject) {
+          var xhr = new XMLHttpRequest();
+          xhr.responseType = 'application/json';
+          xhr.open('POST', GCM_REGISTRATION_URL, true);
+          xhr.setRequestHeader('Content-Type', 'application/json');
+          xhr.setRequestHeader('Authorization', 'Bearer ' + token);
+          xhr.setRequestHeader('project_id', GCM_PROJECT_ID);
+          var payload = {
+            'operation': 'add',
+            'notification_key_name': username,
+            'registration_ids': [gcmId]
+          };
+          xhr.onloadend = function() {
+            if (xhr.status != 200) {
+              reject();
+            }
+            var obj = JSON.parse(xhr.responseText);
+            var key = obj && obj.notification_key;
+            if (!key) {
+              reject();
+            }
+            console.log('gcm notification key POST: ' + key);
+            chrome.storage.local.set({gcmNotificationKey: key});
+            resolve(key);
+          };
+          xhr.send(JSON.stringify(payload));
+        });
+      });
+    }).catch(function() {
+      // Couldn't obtain a GCM ID. Ignore and fallback to polling.
+    });
+  });
+}
+
+/**
+ * Returns a promise resolving to either a cached or new GCM registration ID.
+ * Rejects if registration fails.
+ * @return {Promise} A Promise that resolves to a GCM registration ID.
+ */
+function getGcmRegistrationId() {
+  return fillFromChromeLocalStorage({gcmRegistrationId: undefined})
+      .then(function(items) {
+        if (items.gcmRegistrationId) {
+          console.log('Reused gcm registration id from storage.');
+          return Promise.resolve(items.gcmRegistrationId);
+        }
+
+        return new Promise(function(resolve, reject) {
+          instrumented.gcm.register([GCM_PROJECT_ID], function(registrationId) {
+            console.log('gcm.register(): ' + registrationId);
+            if (registrationId) {
+              chrome.storage.local.set({gcmRegistrationId: registrationId});
+              resolve(registrationId);
+            } else {
+              reject();
+            }
+          });
+        });
+      });
+}
+
+/**
  * Polls the optin state.
  * Sometimes we get the response to the opted in result too soon during
  * push messaging. We'll recheck the optin state a few times before giving up.
  */
 function pollOptedInWithRecheck() {
   /**
    * Cleans up any state used to recheck the opt-in poll.
    */
   function clearPollingState() {
     localStorage.removeItem('optedInCheckCount');
@@ skipping 110 matching lines @@
 
 // Handles state change notifications for the Google Now enabled bit.
 instrumented.storage.onChanged.addListener(function(changes, areaName) {
   if (areaName === 'local') {
     if ('googleNowEnabled' in changes) {
       onStateChange();
     }
   }
 });
 
-instrumented.pushMessaging.onMessage.addListener(function(message) {
-  // message.payload will be '' when the extension first starts.
-  // 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) {
+instrumented.gcm.onMessage.addListener(function(message) {
+  console.log('gcm.onMessage ' + JSON.stringify(message));
+  if (!message || !message.data) {
+    return;
+  }
+
+  var payload = message.data.payload;
+  var tag = message.data.tag;
+  if (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>} */
         notificationGroups: {}
       }, PromiseRejection.ALLOW).then(function(items) {
-        if (items.lastPollNowPayloads[message.subchannelId] !=
-            message.payload) {
-          items.lastPollNowPayloads[message.subchannelId] = message.payload;
+        if (items.lastPollNowPayloads[tag] != payload) {
+          items.lastPollNowPayloads[tag] = payload;
 
-          items.notificationGroups['PUSH' + message.subchannelId] = {
+          items.notificationGroups['PUSH' + tag] = {
             cards: [],
             nextPollTime: Date.now()
           };
 
           chrome.storage.local.set({
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
           pollOptedInWithRecheck();
         }
       });
     });
   }
 });