Using “is opted in” server request

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 56 matching lines @@
  * Time we keep retrying dismissals.
  */
 var MAXIMUM_DISMISSAL_AGE_MS = 24 * 60 * 60 * 1000; // 1 day
 
 /**
  * Time we keep dismissals after successful server dismiss requests.
  */
 var DISMISS_RETENTION_TIME_MS = 20 * 60 * 1000;  // 20 minutes
 
 /**
+ * Default period for checking whether the user is opted in to Google Now.
+ */
+var DEFAULT_OPTIN_CHECK_PERIOD_SECONDS = 60 * 60 * 24 * 7; // 1 week
+
+/**
  * 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 ON_PUSH_MESSAGE_START_TASK_NAME = 'on-push-message';
 
 var LOCATION_WATCH_NAME = 'location-watch';
@@ skipping 328 matching lines @@
         mergedCards[card.chromeNotificationId],
         card,
         storageGroup.cardsTimestamp,
         storageGroup.rank);
   }
 }
 
 /**
  * Schedules next cards poll.
  * @param {Object.<string, StorageGroup>} groups Map from group name to group
- *     information.
+ *     information. If this map is empty, the user is not opted in to Google

[skare_, 2013/10/31 00:49:21]

consider making signed-in state an explicit param

[vadimt, 2013/10/31 14:36:00]

I thought it would make sense as is to keep the extension afloat if the server
sends empty set of groups by mistake. Instead of crashing, the client will
re-request within 1 week. Makes sense?

[rgustafson, 2013/10/31 18:37:59]

It's important to handle the possibility of no groups when the user should be
getting notifications in a way doesn't make the extension stop functioning, but
I don't think using the opted out state is the best way. Maybe another default
value? 1 day?

Btw, extremely unlikely that it would happen, but breaking with no chance of
recovery is bad.

[vadimt, 2013/10/31 19:59:57]

Added parameter. Restored old behavior for opted-in users, which is throw an
exception and retry in 1 hour (we use a recurring timer that never stops).

+ *     Now.
  */
 function scheduleNextPoll(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, 'scheduleNextPoll: nextPollTime is null');
-
-  var nextPollDelaySeconds = Math.max(
-      (nextPollTime - Date.now()) / MS_IN_SECOND,
-      MINIMUM_POLLING_PERIOD_SECONDS);
-  updateCardsAttempts.start(nextPollDelaySeconds);
+  if (nextPollTime != null) {
+    var nextPollDelaySeconds = Math.max(
+        (nextPollTime - Date.now()) / MS_IN_SECOND,
+        MINIMUM_POLLING_PERIOD_SECONDS);
+    updateCardsAttempts.start(nextPollDelaySeconds);
+  } else {
+    instrumented.metricsPrivate.getVariationParams(
+        '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.
  */
 function mergeAndShowNotificationCards(notificationGroups) {
   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);
 
+  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 = {};
+  }
+
   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);
     }
@@ skipping 80 matching lines @@
     }
   };
 
   setAuthorization(request, function(success) {
     if (success)
       request.send();
   });
 }
 
 /**
+ * Requests the account opted-in state from the server.
+ * @param {function()} successCallback Function that will be called if

[skare_, 2013/10/31 00:49:21]

maybe add param to make it successCallback(bool isOptedIn) or rename the
function from successCallback since the request could be ok but user not signed
in.

[vadimt, 2013/10/31 14:36:00]

Done.

+ *     opted-in state is 'true'.
+ */
+function requestOptedIn(successCallback) {
+  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);
+      if (parsedResponse.value) {
+        chrome.storage.local.set({googleNowEnabled: true});
+        successCallback();
+      } else {
+        scheduleNextPoll({});
+      }
+    }
+  };
+
+  setAuthorization(request, function(success) {
+    if (success)
+      request.send();
+  });
+}
+
+/**
  * Requests notification cards from the server.
  * @param {Location} position Location of this computer.
  */
 function requestNotificationCards(position) {
   console.log('requestNotificationCards ' + JSON.stringify(position));
 
-  instrumented.storage.local.get('notificationGroups', function(items) {
+  instrumented.storage.local.get(
+      ['notificationGroups', 'googleNowEnabled'], function(items) {
     console.log('requestNotificationCards-storage-get ' +
                 JSON.stringify(items));
     items = items || {};
 
     var groupsToRequest = [];
 
     if (items.notificationGroups) {
       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);
       }
     }
 
-    requestNotificationGroups(groupsToRequest);
+    if (items.googleNowEnabled) {
+      requestNotificationGroups(groupsToRequest);
+    } else {
+      requestOptedIn(function() {
+        requestNotificationGroups(groupsToRequest);
+      });
+    }
   });
 }
 
 /**
  * Starts getting location for a cards update.
  */
 function requestLocation() {
   console.log('requestLocation');
   recordEvent(GoogleNowEvent.LOCATION_REQUEST);
   // TODO(vadimt): Figure out location request options.
@@ skipping 471 matching lines @@
 });
 
 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) {
     tasks.add(ON_PUSH_MESSAGE_START_TASK_NAME, function() {
-      instrumented.storage.local.get('lastPollNowPayloads', function(items) {
+      instrumented.storage.local.get(
+          ['lastPollNowPayloads', 'notificationGroups'], function(items) {
         // If storage.get fails, it's safer to do nothing, preventing polling
         // the server when the payload really didn't change.
         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;
-          chrome.storage.local.set(
-              {lastPollNowPayloads: items.lastPollNowPayloads});
 
-          updateCardsAttempts.isRunning(function(running) {
-            if (running)
-              requestNotificationGroups(['PUSH' + message.subchannelId]);
+          items.notificationGroups = items.notificationGroups || {};
+          items.notificationGroups['PUSH' + message.subchannelId] = {
+            cards: [],
+            nextPollTime: Date.now()
+          };
+
+          chrome.storage.local.set({
+            lastPollNowPayloads: items.lastPollNowPayloads,
+            notificationGroups: items.notificationGroups
           });
+
+          updateNotificationsCards();
         }
       });
     });
   }
 });