Convert Google Now's State Change Gathering Mechanism to use Promises

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 1069 matching lines @@
   setBackgroundEnable(shouldSetBackground);
   setShouldPollCards(shouldPollCards);
 }
 
 /**
  * Coordinates the behavior of Google Now for Chrome depending on
  * Chrome and extension state.
  */
 function onStateChange() {
   tasks.add(STATE_CHANGED_TASK_NAME, function() {
+    Promise.all([
+        isSignedIn(),
+        isGeolocationEnabled(),
+        canEnableBackground(),
+        isNotificationsEnabled(),
+        isGoogleNowEnabled()])
+        .then(function(results) {
+          updateRunningState.apply(null, results);
+        });
+  });
+}
+
+/**
+ * Determines if the user is signed in.
+ * @return {Promise} A promise to evaluate the signed in state.
+ */
+function isSignedIn() {
+  return new Promise(function(onSuccess) {

[rgustafson, 2014/02/11 03:18:59]

Just out of curiosity, is onSuccess normal promise terminology? It just seems a
bit strange since there isn't really failure/error here. I've seen people using
"resolve".

[robliao, 2014/02/11 17:55:41]

We've got terminology to use onSuccess in the cards code and this is simply an
extension of that.

The success and failure terminology refer to the state of an evaluation: Were we
able to evaluate isSignedIn? Were we able to evaluate if geolocation is enabled?

If these evaluations occurred without problem, then it is a success evaluation.

If there is any failure, it's a failure evaluation.

Plus resolve and reject are awkward expressions for success and fail
evaluations.

     authenticationManager.isSignedIn(function(signedIn) {
-      instrumented.metricsPrivate.getVariationParams(
-          'GoogleNow',
-          function(response) {
-            var canEnableBackground =
-                (!response || (response.canEnableBackground != 'false'));
-            instrumented.notifications.getPermissionLevel(function(level) {
-              var notificationEnabled = (level == 'granted');
-              instrumented.
-                preferencesPrivate.
-                googleGeolocationAccessEnabled.
-                get({}, function(prefValue) {
-                  var geolocationEnabled = !!prefValue.value;
-                  instrumented.storage.local.get(
-                      'googleNowEnabled',
-                      function(items) {
-                        var googleNowEnabled =
-                            items && !!items.googleNowEnabled;
-                        updateRunningState(
-                            signedIn,
-                            geolocationEnabled,
-                            canEnableBackground,
-                            notificationEnabled,
-                            googleNowEnabled);
-                      });
-                });
-            });
-          });
+      onSuccess(signedIn);
     });
   });
 }
+
+/**
+ * Gets the geolocation enabled preference.
+ * @return {Promise} A promise to get the geolocation enabled preference.
+ */
+function isGeolocationEnabled() {
+  return new Promise(function(onSuccess) {
+    instrumented.preferencesPrivate.googleGeolocationAccessEnabled.get(
+        {},
+        function(prefValue) {
+          onSuccess(!!prefValue.value);
+        });
+  });
+}
+
+/**
+ * Determines if background mode should be requested.
+ * @return {Promise} A promise to determine if background can be enabled.
+ */
+function canEnableBackground() {
+  return new Promise(function(onSuccess) {
+    instrumented.metricsPrivate.getVariationParams(
+        'GoogleNow',
+        function(response) {
+          onSuccess(!response || (response.canEnableBackground != 'false'));
+        });
+  });
+}
+
+/**
+ * Checks if Google Now is enabled in the notifications center.
+ * @return {Promise} A promise to determine if Google Now is enabled
+ *     in the notifications center.
+ */
+function isNotificationsEnabled() {
+  return new Promise(function(onSuccess) {
+    instrumented.notifications.getPermissionLevel(function(level) {
+      onSuccess(level == 'granted');
+    });
+  });
+}
+
+/**
+ * Gets the previous Google Now opt-in state

[rgustafson, 2014/02/11 03:18:59]

add .

[robliao, 2014/02/11 17:55:41]

Done.

+ * @return {Promise} A promise to determine the previous Google Now
+ *     opt-in state.
+ */
+function isGoogleNowEnabled() {
+  return new Promise(function(onSuccess) {
+    instrumented.storage.local.get('googleNowEnabled', function(items) {
+      onSuccess(items && !!items.googleNowEnabled);
+    });
+  });
+}
 
 instrumented.runtime.onInstalled.addListener(function(details) {
   console.log('onInstalled ' + JSON.stringify(details));
   if (details.reason != 'chrome_update') {
     initialize();
   }
 });
 
 instrumented.runtime.onStartup.addListener(function() {
   console.log('onStartup');
@@ skipping 101 matching lines @@
             lastPollNowPayloads: items.lastPollNowPayloads,
             notificationGroups: items.notificationGroups
           });
 
           updateNotificationsCards();
         }
       });
     });
   }
 });