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
+ *     Now.
  */
 function scheduleNextPoll(groups) {

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

Why not add another optional param for boolean opted out? Or better yet, use a
different function scheduleNextOptInPoll? 

It's safe to say that if there are groups when opted out, we shouldn't pay
attention to them. Then there's no overlapping code here between the two
functions for scheduling a notifications poll and opt in.

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

Added param. Note that we happen to call this function with a non-constant
param.

   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) {

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

Why not call the function to schedule next poll then early return?

None of the code below is used. It's mostly just for loops with 0 items, but
once you get to showNotificationCards, there's also unnecessary storage reads,
etc. Early return prevents future readers from having to hunt for what else will
happen.

You might still want to count it as cards_parse_success though.

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

We want to delete cards, avoid restoring cards on startup, clean cards triggers,
store empty groups set...

+    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()} 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);
+      if (parsedResponse.value) {
+        chrome.storage.local.set({googleNowEnabled: true});
+        optedInCallback();
+      } 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();
         }
       });
     });
   }
 });