Updated Google Now to Check the Geolocation Access Preference

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 57 matching lines @@
  * Time we keep dismissals after successful server dismiss requests.
  */
 var DISMISS_RETENTION_TIME_MS = 20 * 60 * 1000;  // 20 minutes
 
 /**
  * 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 LOCATION_WATCH_NAME = 'location-watch';
 
 var WELCOME_TOAST_NOTIFICATION_ID = 'enable-now-toast';
 
 /**
  * The indices of the buttons that are displayed on the welcome toast.
  * @enum {number}
  */
 var ToastButtonIndex = {YES: 0, NO: 1};
 
 /**
- * The action that the user performed on the welcome toast.
- * @enum {number}
- */
-var ToastOptionResponse = {CHOSE_YES: 1, CHOSE_NO: 2};
-
-/**
  * Checks if a new task can't be scheduled when another task is already
  * scheduled.
  * @param {string} newTaskName Name of the new task.
  * @param {string} scheduledTaskName Name of the scheduled task.
  * @return {boolean} Whether the new task conflicts with the existing task.
  */
 function areTasksConflicting(newTaskName, scheduledTaskName) {
   if (newTaskName == UPDATE_CARDS_TASK_NAME &&
       scheduledTaskName == UPDATE_CARDS_TASK_NAME) {
     // If a card update is requested while an old update is still scheduled, we
     // don't need the new update.
     return true;
   }
 
   if (newTaskName == RETRY_DISMISS_TASK_NAME &&
       (scheduledTaskName == UPDATE_CARDS_TASK_NAME ||
        scheduledTaskName == DISMISS_CARD_TASK_NAME ||
        scheduledTaskName == RETRY_DISMISS_TASK_NAME)) {
     // No need to schedule retry-dismiss action if another action that tries to
     // send dismissals is scheduled.
     return true;
   }
 
   return false;
 }
 
+var googleGeolocationAccessEnabledPref =
+    chrome.preferencesPrivate.googleGeolocationAccessEnabled;
+
 var tasks = buildTaskManager(areTasksConflicting);
 
 // Add error processing to API calls.
 tasks.instrumentApiFunction(chrome.identity, 'getAuthToken', 1);
 tasks.instrumentApiFunction(chrome.identity, 'removeCachedAuthToken', 1);
 tasks.instrumentApiFunction(chrome.location.onLocationUpdate, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.notifications, 'create', 2);
 tasks.instrumentApiFunction(chrome.notifications, 'update', 2);
 tasks.instrumentApiFunction(chrome.notifications, 'getAll', 0);
 tasks.instrumentApiFunction(
     chrome.notifications.onButtonClicked, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.notifications.onClicked, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.notifications.onClosed, 'addListener', 0);
+tasks.instrumentApiFunction(
+    googleGeolocationAccessEnabledPref.onChange,
+    'addListener',
+    0);
 tasks.instrumentApiFunction(chrome.runtime.onInstalled, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.runtime.onStartup, 'addListener', 0);
 tasks.instrumentApiFunction(chrome.tabs, 'create', 1);
 tasks.instrumentApiFunction(storage, 'get', 1);
 
 var updateCardsAttempts = buildAttemptManager(
     'cards-update',
     requestLocation,
     INITIAL_POLLING_PERIOD_SECONDS,
     MAXIMUM_POLLING_PERIOD_SECONDS);
@@ skipping 240 matching lines @@
       storage.set({
         notificationsData: newNotificationsData,
         recentDismissals: updatedRecentDismissals
       });
       callback();
     });
   });
 }
 
 /**
+ * Removes all cards and card state on Google Now close down.
+ * For example, this occurs when the geolocation preference is unchecked in the
+ * content settings.
+ */
+function removeAllCards() {
+  console.log('removeAllCards');
+
+  // TODO(robliao): Once Google Now clears its own checkbox in the
+  // notifications center and bug 260376 is fixed, the below clearing
+  // code is no longer necessary.
+  chrome.notifications.getAll(function(notifications) {
+    for (var notificationId in notifications) {
+      chrome.notifications.clear(notificationId, function() {});
+    }
+    storage.set({notificationsData: {}});
+  });
+}
+
+/**
  * Requests notification cards from the server.
  * @param {Location} position Location of this computer.
  * @param {function()} callback Completion callback.
  */
 function requestNotificationCards(position, callback) {
   console.log('requestNotificationCards ' + JSON.stringify(position) +
       ' from ' + NOTIFICATION_CARDS_URL);
 
   if (!NOTIFICATION_CARDS_URL) {
     callback();
@@ skipping 34 matching lines @@
 /**
  * Starts getting location for a cards update.
  */
 function requestLocation() {
   console.log('requestLocation');
   recordEvent(DiagnosticEvent.LOCATION_REQUEST);
   // TODO(vadimt): Figure out location request options.
   chrome.location.watchLocation(LOCATION_WATCH_NAME, {});
 }
 
+/**
+ * Stops getting the location.
+ */
+function stopRequestLocation() {
+  console.log('stopRequestLocation');
+  chrome.location.clearWatch(LOCATION_WATCH_NAME);
+}
 
 /**
  * Obtains new location; requests and shows notification cards based on this
  * location.
  * @param {Location} position Location of this computer.
  */
 function updateNotificationsCards(position) {
   console.log('updateNotificationsCards ' + JSON.stringify(position) +
       ' @' + new Date());
   tasks.add(UPDATE_CARDS_TASK_NAME, function(callback) {
     console.log('updateNotificationsCards-task-begin');
-    updateCardsAttempts.planForNext(function() {
-      processPendingDismissals(function(success) {
-        if (success) {
-          // The cards are requested only if there are no unsent dismissals.
-          requestNotificationCards(position, callback);
-        } else {
-          callback();
-        }
-      });
+    updateCardsAttempts.isRunning(function(running) {
+      if (running) {
+        updateCardsAttempts.planForNext(function() {
+          processPendingDismissals(function(success) {
+            if (success) {
+              // The cards are requested only if there are no unsent dismissals.
+              requestNotificationCards(position, callback);
+            } else {
+              callback();
+            }
+          });
+        });
+      }
     });
   });
 }
 
 /**
  * Sends a server request to dismiss a card.
  * @param {string} notificationId Unique identifier of the card.
  * @param {number} dismissalTimeMs Time of the user's dismissal of the card in
  *     milliseconds since epoch.
  * @param {Object} dismissalParameters Dismissal parameters.
@@ skipping 142 matching lines @@
         chrome.windows.create({url: url});
     });
   });
 }
 
 /**
  * Responds to a click of one of the buttons on the welcome toast.
  * @param {number} buttonIndex The index of the button which was clicked.
  */
 function onToastNotificationClicked(buttonIndex) {
+  storage.set({userRespondedToToast: true});
+
   if (buttonIndex == ToastButtonIndex.YES) {
     chrome.metricsPrivate.recordUserAction('GoogleNow.WelcomeToastClickedYes');
-    storage.set({toastState: ToastOptionResponse.CHOSE_YES});
-
-    // TODO(zturner): Update chrome geolocation setting once the settings
-    // API is in place.
-    startPollingCards();
+    googleGeolocationAccessEnabledPref.set({value: true});
+    // The googlegeolocationaccessenabled preference change callback
+    // will take care of starting the poll for cards.
   } else {
     chrome.metricsPrivate.recordUserAction('GoogleNow.WelcomeToastClickedNo');
-    storage.set({toastState: ToastOptionResponse.CHOSE_NO});
+    onStateChange();
   }
-
-  chrome.notifications.clear(
-      WELCOME_TOAST_NOTIFICATION_ID,
-      function(wasCleared) {});
 }
 
 /**
  * Callback for chrome.notifications.onClosed event.
  * @param {string} notificationId Unique identifier of the notification.
  * @param {boolean} byUser Whether the notification was closed by the user.
  */
 function onNotificationClosed(notificationId, byUser) {
   if (!byUser)
     return;
 
   if (notificationId == WELCOME_TOAST_NOTIFICATION_ID) {
     // Even though they only closed the notification without clicking no, treat
     // it as though they clicked No anwyay, and don't show the toast again.
     chrome.metricsPrivate.recordUserAction('GoogleNow.WelcomeToastDismissed');
-    storage.set({toastState: ToastOptionResponse.CHOSE_NO});
+    storage.set({userRespondedToToast: true});
     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(callback) {
     dismissalAttempts.start();
 
     // Deleting the notification in case it was re-added while this task was
@@ skipping 27 matching lines @@
  */
 function startPollingCards() {
   // Create an update timer for a case when for some reason location request
   // gets stuck.
   updateCardsAttempts.start(MAXIMUM_POLLING_PERIOD_SECONDS);
 
   requestLocation();
 }
 
 /**
+ * Stops all machinery in the polling system.
+ */
+function stopPollingCards() {
+  stopRequestLocation();
+
+  updateCardsAttempts.stop();
+
+  removeAllCards();
+}
+
+/**
+ * Stops everything in Google Now, from polling to any displayed UI.
+ */
+function stopAndCloseDown() {
+  stopPollingCards();
+
+  hideWelcomeToast();

[vadimt, 2013/07/24 00:59:38]

hideWelcomeToast() should not be part of this.
It should be called only from setToastVisible().

[robliao, 2013/07/24 20:07:37]

Done.
On 2013/07/24 00:59:38, vadimt wrote:

+}
+
+/**
  * Initializes the event page on install or on browser startup.
  */
 function initialize() {
   recordEvent(DiagnosticEvent.EXTENSION_START);
-  storage.get('toastState', function(items) {
-    // The toast state might be undefined (e.g. not in storage yet) if this is
-    // the first time ever being prompted.
+  onStateChange();

[vadimt, 2013/07/24 00:59:38]

Suppose when we closed Chrome last time, we were in polling state (polling alarm
was on).
Then, on startup, it will be still on.
So, onStateChange() won't do anything.
However, on startup, we have to poll for cards. Couple of options how to achieve
this:
1. Stop updateCardsAttempts before onStateChange here
OR
2. Plumb a parameter to onStateChange forcing to make a first poll immediately
even if polling is on.

(Please test this case)

[robliao, 2013/07/24 20:07:37]

Stopping updateCardsAttempts is best here. It keeps the rest of the code
consistent that depends on this state of updateCardsAttempts consistent.
On 2013/07/24 00:59:38, vadimt wrote:

+}
 
-    // TODO(zturner): Get the value of isGeolocationEnabled from the settings
-    // api and additionally make sure it is true.
-    if (!items.toastState) {
-      if (NOTIFICATION_CARDS_URL) {
-        chrome.identity.getAuthToken({interactive: false}, function(token) {
-          if (!chrome.runtime.lastError && token)
-            showWelcomeToast();
-        });
+/**
+ * Starts or stops the extension machinery.
+ * @param {boolean} shouldRunRequest true to start and
+ *     false to stop this extension.
+ * @param {function} onSuccess Called on completion.
+ */
+function setShouldRun(shouldRunRequest, onSuccess) {
+  tasks.debugSetStepName(
+        'setShouldRun-shouldRun-updateCardsAttemptsIsRunning');
+    updateCardsAttempts.isRunning(function(currentValue) {

[vadimt, 2013/07/24 00:59:38]

Please unindent.

[robliao, 2013/07/24 20:07:37]

Done.

+      if (shouldRunRequest != currentValue) {
+        if (shouldRunRequest)
+          startPollingCards();
+        else
+          stopAndCloseDown();
       }
-    } else if (items.toastState == ToastOptionResponse.CHOSE_YES) {
-      startPollingCards();
+      onSuccess();
+    });
+}
+
+/**
+ * Shows or hides the toast.
+ * @param {boolean} visibleRequest true to show the toast and
+ *     false to hide the toast.
+ * @param {function} onSuccess Called on completion.
+ */
+function setToastVisible(visibleRequest, onSuccess) {
+  tasks.debugSetStepName(
+      'setToastVisible-shouldSetToastVisible-getAllNotifications');
+  chrome.notifications.getAll(function(notifications) {
+    // TODO(vadimt): Figure out what to do when notifications are disabled for
+    // our extension.
+    notifications = notifications || {};
+
+    var notificationFound = false;
+    for (var notificationId in notifications) {
+      if (notificationId == WELCOME_TOAST_NOTIFICATION_ID) {
+        notificationFound = true;
+        break;
+      }
     }
+
+    if ((notificationFound && !visibleRequest) ||
+        (!notificationFound && visibleRequest))

[vadimt, 2013/07/24 00:59:38]

if (visibleRequest != !!notifications[WELCOME_TOAST_NOTIFICATION_ID])

[robliao, 2013/07/24 20:07:37]

Done.

+    {
+      if (visibleRequest)
+        showWelcomeToast();
+      else
+        hideWelcomeToast();
+    }
+
+    onSuccess();
   });
 }
 
+/**
+ * Does the actual work of deciding what Google Now should do
+ * based off of the current state of Chrome.
+ * @param {boolean} signedIn true if the user is signed in.
+ * @param {boolean} geolocationEnabled true if
+ *     the geolocation option is enabled.
+ * @param {boolean} userRespondedToToast true if
+ *     the user has responded to the toast.
+ * @param {function()} callback Call this function on completion.
+ */
+function updateRunningState(
+    signedIn,
+    geolocationEnabled,
+    userRespondedToToast,
+    callback) {
+
+  var toastVisible = false;

[vadimt, 2013/07/24 00:59:38]

toastShouldBeVisible?
Otherwise, it may seem that this variable is about current state.

[robliao, 2013/07/24 20:07:37]

Used shouldSetToastVisible.
On 2013/07/24 00:59:38, vadimt wrote:

+  var shouldRun = false;
+
+  if (signedIn) {
+    if (geolocationEnabled) {
+      if (!userRespondedToToast) {
+        // If the user enabled geolocation independently of Google Now,
+        // the user has implicitly responded to the toast.
+        // We do not want to show it again.
+        storage.set({userRespondedToToast: true});
+      }
+
+      shouldRun = true;
+    } else {
+      if (userRespondedToToast) {
+        shouldRun = false;

[vadimt, 2013/07/24 00:59:38]

Already false.

[robliao, 2013/07/24 20:07:37]

Kept here for state machine clarity.
On 2013/07/24 00:59:38, vadimt wrote:

[vadimt, 2013/07/24 20:49:43]

Then you should always set both variables in all branches.
OR
You can remove "= false" assignments. It may happen that once you do this,
you'll like the succinct, declarative and easily understandable result.

[robliao, 2013/07/24 21:07:06]

State machine implementations should generally be explicit rather than implicit
to make sure you cover all states you need to cover.

I've removed the =falses.

I think we agree to disagree here.

On 2013/07/24 20:49:43, vadimt wrote:

+      } else {
+        toastVisible = true;
+      }
+    }
+  } else {
+    shouldRun = false;

[vadimt, 2013/07/24 00:59:38]

Already false.

[robliao, 2013/07/24 20:07:37]

Kept here for state machine clarity.

Ideally, the variables above should be uninitialized. Initializing them provides
us robustness against future bugs by providing a known valid initial start
state.
On 2013/07/24 00:59:38, vadimt wrote:

[vadimt, 2013/07/24 20:49:43]

For me, assigning to false is stating "nothing is done unless explicitly told to
do so".

[robliao, 2013/07/24 21:07:06]

Done.

+  }
+
+  setToastVisible(toastVisible, function() {

[vadimt, 2013/07/24 00:59:38]

With new simplified tasks, you don't have to invoke finish callback. Therefore,
no need for setToastVisible and setShouldRun to take a callback parameter and be
executed in a cascaded way.

[robliao, 2013/07/24 20:07:37]

Is the new simplified tasks checked in?
On 2013/07/24 00:59:38, vadimt wrote:

[vadimt, 2013/07/24 20:49:43]

No, but will be by the moment you'll be checking in.

[robliao, 2013/07/24 21:07:06]

Do you have a delta I can pull?
On 2013/07/24 20:49:43, vadimt wrote:

+    setShouldRun(shouldRun, callback);
+  });
+}
+
+/**
+ * Coordinates the behavior of Google Now for Chrome depending on
+ * Chrome and extension state.
+ */
+function onStateChange() {
+  tasks.add(STATE_CHANGED_TASK_NAME, function(callback) {
+    tasks.debugSetStepName('onStateChange-getAuthToken');
+    chrome.identity.getAuthToken({interactive: false}, function(token) {
+      var signedIn =
+          !chrome.runtime.lastError &&
+          token &&
+          !!NOTIFICATION_CARDS_URL;
+      tasks.debugSetStepName(
+          'onStateChange-get-googleGeolocationAccessEnabledPref');
+      googleGeolocationAccessEnabledPref.get({}, function(prefValue) {
+        var geolocationEnabled = !!prefValue.value;
+        tasks.debugSetStepName(
+          'onStateChange-get-userRespondedToToast');
+        storage.get('userRespondedToToast', function(items) {
+          var userRespondedToToast = !!items.userRespondedToToast;
+          updateRunningState(
+              signedIn,
+              geolocationEnabled,
+              userRespondedToToast,
+              callback);
+        });
+      });
+    });
+  });
+}
+
 /**
  * Displays a toast to the user asking if they want to opt in to receiving
  * Google Now cards.
  */
 function showWelcomeToast() {
   recordEvent(DiagnosticEvent.SHOW_WELCOME_TOAST);
   // TODO(zturner): Localize this once the component extension localization
   // api is complete.
   // TODO(zturner): Add icons.
   var buttons = [{title: 'Yes'}, {title: 'No'}];
   var options = {
     type: 'basic',
     title: 'Enable Google Now Cards',
     message: 'Would you like to be shown Google Now cards?',
     iconUrl: 'http://www.gstatic.com/googlenow/chrome/default.png',
     priority: 2,
     buttons: buttons
   };
   chrome.notifications.create(WELCOME_TOAST_NOTIFICATION_ID, options,
       function(notificationId) {});
 }
 
+/**
+ * Hides the welcome toast.
+ */
+function hideWelcomeToast() {
+  chrome.notifications.clear(
+      WELCOME_TOAST_NOTIFICATION_ID,
+      function() {});
+}
+
 chrome.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     initialize();
   }
 });
 
 chrome.runtime.onStartup.addListener(function() {
   console.log('onStartup');
   initialize();
 });
 
+googleGeolocationAccessEnabledPref.onChange.addListener(function(prefValue) {
+  console.log('googleGeolocationAccessEnabledPref onChange ' + prefValue.value);
+  onStateChange();
+});
+
 chrome.notifications.onClicked.addListener(
     function(notificationId) {
       chrome.metricsPrivate.recordUserAction('GoogleNow.MessageClicked');
       onNotificationClicked(notificationId, function(actionUrls) {
         return actionUrls.messageUrl;
       });
     });
 
 chrome.notifications.onButtonClicked.addListener(
     function(notificationId, buttonIndex) {
@@ skipping 15 matching lines @@
 
 chrome.location.onLocationUpdate.addListener(function(position) {
   recordEvent(DiagnosticEvent.LOCATION_UPDATE);
   updateNotificationsCards(position);
 });
 
 chrome.omnibox.onInputEntered.addListener(function(text) {
   localStorage['server_url'] = NOTIFICATION_CARDS_URL = text;
   initialize();
 });