Finished storage polyfill.

src/js/polyfills/storage.polyfill.js

 // Copyright 2015 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 /**
  * Polyfill for Chrome Apps' storage API.
  */
 
 'use strict';
 
 if (!chrome.storage)
   chrome.storage = {};
 
+chrome.caterpillar.storage = {};
+
 (function() {
 
 /**
  * Triggers a chrome.storage.onChanged event on self.
  *
  * This is used internally within the polyfill to manage change events; event
  * information is stored in event.detail.
  *
  * @param {object} items Object mapping keys to StorageChanges containing the
  *     new and old values of each item.
  */
 function triggerOnChanged(items) {
   var event = new CustomEvent('chrome.storage.onChanged', {'detail': items});
   self.dispatchEvent(event);
 };
 
 /**
+ * Stores onChanged event listeners.
+ */
+var onChangedListeners = [];
+
+/**
  * Represents a change in stored data.
  */
 chrome.storage.StorageChange = class {
   /**
    * @param {object=} opt_oldValue The old value of the item.
    * @param {object=} opt_newValue The new value of the item.
    */
   constructor(opt_oldValue, opt_newValue) {
     this.oldValue = opt_oldValue;
     this.newValue = opt_newValue;
-  };
+  }
 };
 
 /**
  * Represents an area where data can be stored.
  *
  * Chrome Apps have three such areas - sync, local, managed.
  */
 chrome.storage.StorageArea = class {
   /**
    * Gets one or more items from storage.
    *
-   * @param {string | string[] | object} opt_keys A single key to get, list
+   * @param {string= | string[]= | object=} opt_keys A single key to get, list
    *     of keys to get, or a dictionary specifying default values. Empty lists
    *     or objects return empty results. Pass null to get all contents.
    * @param {function} callback Callback with storage items, or on failure.
    */
   get(opt_keys, callback) {
-    // Handle the optional argument being *first*.
+    // Juggle arguments.
     if (callback === undefined) {
       // Keys wasn't actually given, the callback was.
       callback = opt_keys;
       opt_keys = null;
     }
 
     // Four scenarios:
     // 1. Input is a single string key; retrieve associated value.
     // 2. Input is multiple string keys; retrieve associated values.
     // 3. Input is a map from string key to default value; retrieve associated
@@ skipping 43 matching lines @@
                 items[keys[i]] = opt_keys[keys[i]];
               } else {
                 items[keys[i]] = values[i];
               }
             }
             callback(items);
           })
           .catch(handleError);
     }
   }
+
+  /**
+   * Gets the amount of space (in bytes) being used by one or more items.
+   *
+   * Not implemented in this polyfill.
+   *
+   * @param {string= | string[]= | object=} opt_keys A single key to get,
+   *  list of keys to get, or a dictionary specifying default values. Empty

[raymes, 2016/01/18 00:25:20]

nit: 4 space indent (here and below)

[Matthew Alger, 2016/01/18 00:37:37]

Done.

+   *  lists or objects return 0. Pass null to get total usage.
+   * @param {function} callback Callback with bytes in use, or failure.
+   */
+  getBytesInUse(opt_keys, callback) {
+    // Juggle arguments.
+    if (callback === undefined) {
+      callback = opt_keys;
+      opt_keys = null;
+    }
+    // IndexedDB doesn't support this, so neither does localforage.
+    chrome.caterpillar.setError('getBytesInUse not implemented.');
+    callback();
+  }
+
+  /**
+   * Sets multiple items.
+   *
+   * @param {object} items An object which gives key/value pairs to update
+   *  storage with. Other key/value pairs in storage will not be affected.
+   * @param {function=} opt_callback Callback on success or failure.
+   */
+  set(items, opt_callback) {
+    var keys = Object.keys(items);
+    try {
+      // We need to trigger an event containing all the old values and new values.
+      // To do that, we first need the old values.
+      this.get(keys, function (oldItems) {
+        // Now that we have the old values, we can set the new values.
+        Promise.all(keys.map(key => localforage.setItem(key, items[key])))
+            // Then setup the input and trigger the event.
+            .then(function() {
+              var changes = {};
+              for (var key of keys) {
+                changes[key] = new chrome.storage.StorageChange(
+                    oldItems[key], items[key]);
+              }
+              triggerOnChanged(changes);
+              if (opt_callback !== undefined)
+                opt_callback();
+            });
+      });
+    } catch (e) {
+      chrome.caterpillar.setError('Error setting values: ' + (e.message || e));
+      opt_callback();

[raymes, 2016/01/18 00:25:20]

what if opt_callback is undefined?

[Matthew Alger, 2016/01/18 00:37:37]

Done.

+    }
+  }
+
+  /**
+   * Removes one or more items from storage.
+   *
+   * @param {string || string[]} keys A single key or a list of keys to
+   *  remove.
+   * @param {function=} opt_callback Callback on success or failure.
+   */
+  remove(keys, opt_callback) {
+    var handleError = function(err) {
+      chrome.caterpillar.setError('Error removing keys: ' + err);
+      opt_callback();

[raymes, 2016/01/18 00:25:20]

what if opt_callback is undefined?

[Matthew Alger, 2016/01/18 00:37:37]

Done.

+    };
+    try {
+      this.get(keys, function(items) {
+        if (Array.isArray(keys)) {

[raymes, 2016/01/18 00:25:20]

If keys is a string, you could turn it into an array and just have a single
codepath here. This would remove some code duplication. 

You could do this to remove one codepath in get() as well (optional).

[Matthew Alger, 2016/01/18 00:37:37]

Oh, good idea! Done, and done in get too.

+          Promise.all(keys.map(key => localforage.removeItem(key)))
+              .then(function() {
+                var changes = {};
+                for (var key of keys) {
+                  changes[key] = new chrome.storage.StorageChange(
+                      items[key], null);
+                }
+                triggerOnChanged(changes);
+                opt_callback();

[raymes, 2016/01/18 00:25:20]

what if opt_callback is undefined?

[Matthew Alger, 2016/01/18 00:37:37]

Done.

+              })
+        } else {
+          localforage.removeItem(keys).then(function() {
+            var changes = {};
+            changes[keys] = new chrome.storage.StorageChange(
+                items[keys], null);
+            triggerOnChanged(changes);
+            opt_callback();
+          });
+        }
+      });
+    } catch (e) {
+      handleError(e.message || e);
+    }
+  }
+
+  /**
+   * Removes all items from storage.
+   *
+   * @param {function=} opt_callback Callback on success or failure.
+   */
+  clear(opt_callback) {
+    try {
+      this.get(function(items) {
+        var changes = {};
+        for (var key in items) {
+          changes[key] = new chrome.storage.StorageChange(items[key], null);
+        }
+        triggerOnChanged(changes);
+        localforage.clear(opt_callback);

[raymes, 2016/01/18 00:25:20]

I think it's probably better to clear things before the callback is called
because the callbacks might rely on this. You should do this in the callback for
clear()

[Matthew Alger, 2016/01/18 00:37:37]

Do you mean it's better to clear things before the onChanged event is triggered?
The callback is already called after clear.

I assume you mean the trigger, so I've fixed that.

+      });
+    } catch (e) {
+      chrome.caterpillar.setError('Error clearing values: ' + (e.message || e));
+      if (opt_callback)

[raymes, 2016/01/18 00:25:20]

This is inconsistent with other places where you have if (opt_callback !=
undefined). I would suggest using this notation everywhere since it's clearer
and there's no real downsides (e.g. if opt_callback did not evaluate to true
then we would not want to try to call it anyway).

[Matthew Alger, 2016/01/18 00:37:37]

Changed everything to just check opt_callback's truthiness.

+        opt_callback();
+    }
+  }
 };
 
 /**
  * Items in the local storage area are stored locally.
  */
 chrome.storage.local = new chrome.storage.StorageArea();
 
 /**
  * Items in the sync storage area would be synced using Chrome Sync; in this
  * polyfill we just use local storage.
  */
 chrome.storage.sync = chrome.storage.local;
 
 /**
  * Items in the managed storage area are read-only usually; in this polyfill
  * managed is the same as local storage.
  */
 chrome.storage.managed = chrome.storage.local;
 
 /**
  * Namespace.
  */
 chrome.storage.onChanged = {};
 
 /**
  * Adds an event listener for the onChanged event.
  *
- * @param {function} callback Function taking a changes object of key/value
- *     pairs.
+ * @param {function} callback Function taking an object mapping changed keys to
+ *     StorageChanges and an area name (though the latter will always be null).
  */
 chrome.storage.onChanged.addListener = function(callback) {
-  self.addEventListener('chrome.storage.onChanged', e => {
-    callback(e.detail);
-  });
+  var listener = function(e) {
+    callback(e.detail, null);
+  };
+
+  self.addEventListener('chrome.storage.onChanged', listener);
+  onChangedListeners.push(listener);
+};
+
+/**
+ * Resets onChanged event listeners. Used for testing.
+ */
+chrome.caterpillar.storage.resetOnChangedListenersForTests = function() {
+  for (var listener of onChangedListeners) {
+    self.removeEventListener('chrome.storage.onChanged', listener);
+  }
+
+  onChangedListeners.length = 0;
 };
 
 }).call(this);