Convert garden-o-matic guts over to promises where appropriate

Tools/GardeningServer/scripts/base.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 58 matching lines @@
         result.push(value);
     });
     return result;
 };
 
 base.flattenArray = function(arrayOfArrays)
 {
     if (!arrayOfArrays.length)
         return [];
     return arrayOfArrays.reduce(function(left, right) {
-        return left.concat(right);  
+        return left.concat(right);
     });
 };
 
 base.filterDictionary = function(dictionary, predicate)
 {
     var result = {};
 
     for (var key in dictionary) {
         if (predicate(key))
             result[key] = dictionary[key];
@@ skipping 59 matching lines @@
     if (!jsonp.match(/^[^{[]*\(/))
         return JSON.parse(jsonp);
 
     var startIndex = jsonp.indexOf('(') + 1;
     var endIndex = jsonp.lastIndexOf(')');
     if (startIndex == 0 || endIndex == -1)
         return {};
     return JSON.parse(jsonp.substr(startIndex, endIndex - startIndex));
 };
 
-base.RequestTracker = function(requestsInFlight, callback, args)

[abarth-chromium, 2014/02/20 06:18:52]

\o/

-{
-    this._requestsInFlight = requestsInFlight;
-    this._callback = callback;
-    this._args = args || [];
-    this._tryCallback();
-};
-
-base.RequestTracker.prototype = {
-    _tryCallback: function()
-    {
-        if (!this._requestsInFlight && this._callback)
-            this._callback.apply(null, this._args);
-    },
-    requestComplete: function()
-    {
-        --this._requestsInFlight;
-        this._tryCallback();
-    }
-}
-
-base.callInParallel = function(functionList, callback)
-{
-    var requestTracker = new base.RequestTracker(functionList.length, callback);
-
-    $.each(functionList, function(index, func) {
-        func(function() {
-            requestTracker.requestComplete();
-        });
-    });
-};
-
 base.AsynchronousCache = function(fetch)
 {
     this._fetch = fetch;
     this._dataCache = {};
     this._callbackCache = {};
 };
 
-base.AsynchronousCache.prototype.get = function(key, callback)
+base.AsynchronousCache.prototype.get = function(key)
 {
     var self = this;
+    return new Promise(function(resolve, reject) {
 
-    if (self._dataCache[key]) {
-        // FIXME: Consider always calling callback asynchronously.
-        callback(self._dataCache[key]);
-        return;
-    }
+        if (self._dataCache[key]) {
+            // FIXME: Consider always calling callback asynchronously.
+            resolve(self._dataCache[key]);
+            return;
+        }
 
-    if (key in self._callbackCache) {
-        self._callbackCache[key].push(callback);
-        return;
-    }
+        if (key in self._callbackCache) {
+            self._callbackCache[key].push(resolve);
+            return;
+        }
 
-    self._callbackCache[key] = [callback];
+        self._callbackCache[key] = [resolve];
 
-    self._fetch.call(null, key, function(data) {
-        self._dataCache[key] = data;
+        self._fetch.call(null, key).then(function(data) {
+            self._dataCache[key] = data;
 
-        var callbackList = self._callbackCache[key];
-        delete self._callbackCache[key];
+            var callbackList = self._callbackCache[key];
+            delete self._callbackCache[key];
 
-        callbackList.forEach(function(cachedCallback) {
-            cachedCallback(data);
+            callbackList.forEach(function(cachedCallback) {
+                cachedCallback(data);
+            });
         });
     });
 };
 
 base.AsynchronousCache.prototype.clear = function()
 {
     this._dataCache = {};
     this._callbackCache = {};
-}
+};
 
 /*
     Maintains a dictionary of items, tracking their updates and removing items that haven't been updated.
     An "update" is a call to the "update" method.
     To remove stale items, call the "remove" method. It will remove all
     items that have not been been updated since the last call of "remove".
 */
 base.UpdateTracker = function()
 {
     this._items = {};
@@ skipping 134 matching lines @@
 {
     var link = document.createElement('a');
     link.href = url;
     if (opt_target)
         link.target = opt_target;
     link.appendChild(document.createTextNode(textContent));
     return link;
 }
 
 })();