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

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

You don't need this method. You already have stopPollingCards().

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

Done.

+  stopPollingCards();
+}
+
+/**
  * 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.
+  stopAndCloseDown();
+  onStateChange();
+}
+
+/**
+ * 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) {
+    if (shouldRunRequest != currentValue) {
+      if (shouldRunRequest)
+        startPollingCards();
+      else
+        stopAndCloseDown();
     }
+    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 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;
+      } else {
+        shouldSetToastVisible = true;
+      }
+    }
+  } else {
+    shouldRun = false;
+  }
+
+  setToastVisible(shouldSetToastVisible, function() {
+    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();
 });