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();
+}
+
+/**
  * 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.
 
-    // 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();
-        });
-      }
-    } else if (items.toastState == ToastOptionResponse.CHOSE_YES) {
-      startPollingCards();
+  // Alarms persist across chrome restarts. This is undesirable since it
+  // prevents us from starting up everything (alarms are a heuristic to
+  // determine if we are already running). To mitigate this, we will
+  // shut everything down on initialize before starting everything up.
+  stopPollingCards();

[vadimt, 2013/07/25 20:48:01]

I'm afraid that this scenario is possible:
1. When we closed Chrome, polling was on. alarm was registered.
2. User opens Chrome and quickly opts out from geolocation (or starts without
Google Now flag, opts out and then starts with the flag again).
3. Extension gets loaded.
4. Extension calls stopPollingCards();
5. onStateChange does nothing (correctly) because geolocation is off.
6. Alarms finally loads all alarms, and we start polling, which is wrong.

Do you also think this is possible? If so, this should be addressed.

[robliao, 2013/07/25 22:35:48]

It is, but that bug is beyond the scope of this delta.
On 2013/07/25 20:48:01, vadimt wrote:

[vadimt, 2013/07/26 01:00:37]

Please add a TODO item and plan addressing this soon, because continuing showing
cards after the user opted out is a serious privacy issue.

[robliao, 2013/07/26 01:12:17]

This would be better expressed as a bug rather than a TODO. Neither the fix nor
the workaround is local to this area.
On 2013/07/26 01:00:37, vadimt wrote:

+  onStateChange();
+}
+
+/**
+ * Starts or stops the polling of cards.
+ * @param {boolean} shouldPollCardsRequest true to start and
+ *     false to stop polling cards.
+ * @param {function} onSuccess Called on completion.
+ */
+function setShouldPollCards(shouldPollCardsRequest, onSuccess) {
+  tasks.debugSetStepName(
+        'setShouldRun-shouldRun-updateCardsAttemptsIsRunning');
+  updateCardsAttempts.isRunning(function(currentValue) {
+    if (shouldPollCardsRequest != currentValue) {
+      if (shouldPollCardsRequest)
+        startPollingCards();
+      else
+        stopPollingCards();
     }
+    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 || {};
+
+    if (visibleRequest != !!notifications[WELCOME_TOAST_NOTIFICATION_ID]) {
+      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 shouldSetToastVisible = false;
+  var shouldPollCards = 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});
+      }
+
+      shouldPollCards = true;
+    } else {
+      if (!userRespondedToToast)
+        shouldSetToastVisible = true;
+    }
+  }
+
+  setToastVisible(shouldSetToastVisible, function() {
+    setShouldPollCards(shouldPollCards, 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();
 });