Convert Google Now's use of chrome.local.storage.get to use Promises

chrome/browser/resources/google_now/utility.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 Utility objects and functions for Google Now extension.
  * Most important entities here:
  * (1) 'wrapper' is a module used to add error handling and other services to
@@ skipping 305 matching lines @@
         verify(!isInWrappedCallback, 'Re-entering instrumented callback');
         isInWrappedCallback = true;
 
         if (!opt_isEventListener)
           delete pendingCallbacks[callbackId];
 
         if (wrapperPluginInstance)
           wrapperPluginInstance.prologue();
 
         // Call the original callback.
-        callback.apply(null, arguments);
+        var returnValue = callback.apply(null, arguments);
 
         if (wrapperPluginInstance)
           wrapperPluginInstance.epilogue();
 
         verify(isInWrappedCallback,
                'Instrumented callback is not instrumented upon exit');
         isInWrappedCallback = false;
+
+        return returnValue;
       } catch (error) {
         reportError(error);
       }
     };
   }
 
   /**
    * Returns an instrumented function.
    * @param {!Array.<string>} functionIdentifierParts Path to the chrome.*
    *     function.
@@ skipping 83 matching lines @@
     checkInWrappedCallback: checkInWrappedCallback,
     debugGetStateString: debugGetStateString
   };
 })();
 
 wrapper.instrumentChromeApiFunction('alarms.get', 1);
 wrapper.instrumentChromeApiFunction('alarms.onAlarm.addListener', 0);
 wrapper.instrumentChromeApiFunction('identity.getAuthToken', 1);
 wrapper.instrumentChromeApiFunction('identity.onSignInChanged.addListener', 0);
 wrapper.instrumentChromeApiFunction('identity.removeCachedAuthToken', 1);
+wrapper.instrumentChromeApiFunction('storage.local.get', 1);
 wrapper.instrumentChromeApiFunction('webstorePrivate.getBrowserLogin', 0);
 
 /**
  * Add task tracking support to Promise.then.
  * @override
  */
 Promise.prototype.then = function() {
   var originalThen = Promise.prototype.then;
   return function(callback) {
     return originalThen.call(this, wrapper.wrapCallback(callback, false));
   }
 }();
 
 /**
  * Add task tracking support to Promise.catch.
  * @override
  */
 Promise.prototype.catch = function() {
   var originalCatch = Promise.prototype.catch;
   return function(callback) {
     return originalCatch.call(this, wrapper.wrapCallback(callback, false));
   }
 }();
 
+
+/*

[skare_, 2014/02/20 00:17:12]

nit: /* -> /** and in :472 
(sorry!)

[robliao, 2014/02/21 21:25:45]

Done.

+ * Disallow promise rejection.
+ * @type {boolean}
+ * @const
+ */
+var NO_PROMISE_REJECTION = false;

[skare_, 2014/02/20 00:17:12]

(no action required)
this works; could make an @enum {boolean} too

[robliao, 2014/02/21 21:25:45]

Done.

+
+/*
+ * Allow promise rejection.
+ * @type {boolean}
+ * @const
+ */
+var ALLOW_PROMISE_REJECTION = true;
+
+/**
+ * Provides the promise equivalent of instrumented.chrome.local.get.

[skare_, 2014/02/20 00:17:12]

instrumented.chrome.storage.local?

[robliao, 2014/02/21 21:25:45]

Done.

+ * @param {Object} defaultStorageObject Default storage object to fill.
+ * @param {boolean} opt_allowPromiseRejection If ALLOW_PROMISE_REJECTION,
+ *     allows promise rejection on errors, otherwise the default storage
+ *     object is resolved.
+ * @return {Promise} A promise that fills the default storage object. On

[skare_, 2014/02/20 00:17:12]

just as a first-read opinion, "fills" is slightly confusing but that might just
be me. It's basically "get from" or "read from" right? (those aren't great
suggestions because they might make a couple things wordy elsewhere)

[robliao, 2014/02/21 21:25:45]

I'm open to other suggestions.

I chose fill because we are filling the object in, replacing default values with
the stored values.

get didn't work because we return the default object if anything failed.
On 2014/02/20 00:17:12, Travis Skare wrote:

+ *     failure, if promise rejection is a allowed, the promise is rejected,

[skare_, 2014/02/20 00:17:12]

nit: is a allowed -> is allowed

[robliao, 2014/02/21 21:25:45]

Done.

+ *     otherwise it is resolved to the default storage object.
+ */
+function fillFromChromeLocalStorage(
+    defaultStorageObject,
+    opt_allowPromiseRejection) {
+  return new Promise(function(resolve, reject) {
+    instrumented.storage.local.get(defaultStorageObject, function(items) {
+      if (items) {
+        resolve(items);
+      } else if (opt_allowPromiseRejection === ALLOW_PROMISE_REJECTION) {
+        reject();
+      } else {
+        resolve(defaultStorageObject);
+      }
+    });
+  });
+}
+
 /**
  * Builds the object to manage tasks (mutually exclusive chains of events).
  * @param {function(string, string): boolean} areConflicting Function that
  *     checks if a new task can't be added to a task queue that contains an
  *     existing task.
  * @return {Object} Task manager interface.
  */
 function buildTaskManager(areConflicting) {
   /**
    * Queue of scheduled tasks. The first element, if present, corresponds to the
@@ skipping 221 matching lines @@
     chrome.alarms.clear(alarmName);
     chrome.storage.local.remove(currentDelayStorageKey);
   }
 
   /**
    * Plans for the next attempt.
    * @param {function()} callback Completion callback. It will be invoked after
    *     the planning is done.
    */
   function planForNext(callback) {
-    instrumented.storage.local.get(currentDelayStorageKey, function(items) {
-      if (!items) {
-        items = {};
-        items[currentDelayStorageKey] = maximumDelaySeconds;
-      }
+    var request = {};
+    request[currentDelayStorageKey] = maximumDelaySeconds;
+    fillFromChromeLocalStorage(request).then(function(items) {
       console.log('planForNext-get-storage ' + JSON.stringify(items));
       scheduleNextAttempt(items[currentDelayStorageKey]);
       callback();
     });
   }
 
   instrumented.alarms.onAlarm.addListener(function(alarm) {
     if (alarm.name == alarmName)
       isRunning(function(running) {
         if (running)
@@ skipping 73 matching lines @@
   function addListener(callback) {
     listeners.push(callback);
   }
 
   /**
    * Checks if the last signed in state matches the current one.
    * If it doesn't, it notifies the listeners of the change.
    */
   function checkAndNotifyListeners() {
     isSignedIn().then(function(signedIn) {
-      instrumented.storage.local.get('lastSignedInState', function(items) {
-        items = items || {};
-        if (items.lastSignedInState != signedIn) {
-          chrome.storage.local.set(
-              {lastSignedInState: signedIn});
-          listeners.forEach(function(callback) {
-            callback();
-          });
-        }
+      fillFromChromeLocalStorage({lastSignedInState: undefined})
+          .then(function(items) {
+            if (items.lastSignedInState != signedIn) {
+              chrome.storage.local.set(
+                  {lastSignedInState: signedIn});
+              listeners.forEach(function(callback) {
+                callback();
+              });
+            }
+        });
       });
-    });
   }
 
   instrumented.identity.onSignInChanged.addListener(function() {
     checkAndNotifyListeners();
   });
 
   instrumented.alarms.onAlarm.addListener(function(alarm) {
     if (alarm.name == alarmName)
       checkAndNotifyListeners();
   });
 
   // Poll for the sign in state every hour.
   // One hour is just an arbitrary amount of time chosen.
   chrome.alarms.create(alarmName, {periodInMinutes: 60});
 
   return {
     addListener: addListener,
     getAuthToken: getAuthToken,
     isSignedIn: isSignedIn,
     removeToken: removeToken
   };
 }