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

Tools/GardeningServer/scripts/results.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 56 matching lines @@
     // FIXME: Add support for the rest of the result types.
 ];
 
 // Kinds of results.
 results.kActualKind = 'actual';
 results.kExpectedKind = 'expected';
 results.kDiffKind = 'diff';
 results.kUnknownKind = 'unknown';
 
 // Types of tests.
-results.kImageType = 'image'
-results.kAudioType = 'audio'
-results.kTextType = 'text'
+results.kImageType = 'image';
+results.kAudioType = 'audio';
+results.kTextType = 'text';
 // FIXME: There are more types of tests.
 
 function possibleSuffixListFor(failureTypeList)
 {
     var suffixList = [];
 
     function pushImageSuffixes()
     {
         suffixList.push(kExpectedImageSuffix);
         suffixList.push(kActualImageSuffix);
@@ skipping 98 matching lines @@
 function resultsSummaryURL(builderName)
 {
     return resultsDirectoryURL(builderName) + kResultsName;
 }
 
 function resultsSummaryURLForBuildNumber(builderName, buildNumber)
 {
     return resultsDirectoryURLForBuildNumber(builderName, buildNumber) + kResultsName;
 }
 
-var g_resultsCache = new base.AsynchronousCache(function (key, callback) {
-    net.jsonp(key).then(callback);
+var g_resultsCache = new base.AsynchronousCache(function(key) {
+    return net.jsonp(key);
 });
 
 results.ResultAnalyzer = base.extends(Object, {
     init: function(resultNode)
     {
         this._isUnexpected = resultNode.is_unexpected;
         this._actual = resultNode ? results.failureTypeList(resultNode.actual) : [];
         this._expected = resultNode ? this._addImpliedExpectations(results.failureTypeList(resultNode.expected)) : [];
     },
     _addImpliedExpectations: function(resultsList)
@@ skipping 96 matching lines @@
 {
     var collectedResults = [];
     $.each(dictionaryOfResultNodes, function(key, resultNode) {
         var analyzer = new results.ResultAnalyzer(resultNode);
         collectedResults = collectedResults.concat(analyzer.unexpectedResults());
     });
     return base.uniquifyArray(collectedResults);
 };
 
 // Callback data is [{ buildNumber:, url: }]
-function historicalResultsLocations(builderName, callback)
+function historicalResultsLocations(builderName)
 {
     var historicalResultsData = [];
-
     function parseListingDocument(prefixListingDocument) {
         $(prefixListingDocument).find("Prefix").each(function() {
             var buildString = this.textContent.replace(config.resultsDirectoryNameFromBuilderName(builderName) + '/', '');
             if (buildString.match(/\d+\//)) {
                 var buildNumber = parseInt(buildString);
                 var resultsData = {
                     'buildNumber': buildNumber,
                     'url': resultsSummaryURLForBuildNumber(builderName, buildNumber)
                 };
                 historicalResultsData.unshift(resultsData);
-           }
+            }
         });
         var nextMarker = $(prefixListingDocument).find('NextMarker').get();
         if (nextMarker.length) {
             var nextListingURL = resultsPrefixListingURL(builderName, nextMarker[0].textContent);
-            net.xml(nextListingURL).then(parseListingDocument);
+            return net.xml(nextListingURL).then(function(doc) {
+                return parseListingDocument(doc);
+            });
         } else {
-            callback(historicalResultsData);
+            return historicalResultsData;
         }
     }
 
-    builders.mostRecentBuildForBuilder(builderName, function (mostRecentBuildNumber) {
+    return builders.mostRecentBuildForBuilder(builderName).then(function (mostRecentBuildNumber) {
         var marker = config.resultsDirectoryNameFromBuilderName(builderName) + "/" + (mostRecentBuildNumber - 100) + "/";
         var listingURL = resultsPrefixListingURL(builderName, marker);
-        net.xml(listingURL).then(parseListingDocument);
+        return net.xml(listingURL).then(function(doc) {
+            return parseListingDocument(doc);
+        });
     });
 }
 
-function walkHistory(builderName, testName, callback)
+// This will repeatedly call continueCallback(revision, resultNode) until it returns false.
+function walkHistory(builderName, testName, continueCallback)
 {
     var indexOfNextKeyToFetch = 0;
     var keyList = [];
 
     function continueWalk()
     {
         if (indexOfNextKeyToFetch >= keyList.length) {
             processResultNode(0, null);
             return;
         }
 
         var resultsURL = keyList[indexOfNextKeyToFetch].url;
         ++indexOfNextKeyToFetch;
-        g_resultsCache.get(resultsURL, function(resultsTree) {
+        g_resultsCache.get(resultsURL).then(function(resultsTree) {
             if ($.isEmptyObject(resultsTree)) {
                 continueWalk();
                 return;
             }
             var resultNode = results.resultNodeForTest(resultsTree, testName);
-            var revision = parseInt(resultsTree['blink_revision'])
+            var revision = parseInt(resultsTree['blink_revision']);
             if (isNaN(revision))
                 revision = 0;
             processResultNode(revision, resultNode);
         });
     }
 
     function processResultNode(revision, resultNode)
     {
-        var shouldContinue = callback(revision, resultNode);
+        var shouldContinue = continueCallback(revision, resultNode);
         if (!shouldContinue)
             return;
         continueWalk();
     }
 
-    historicalResultsLocations(builderName, function(resultsLocations) {
+    historicalResultsLocations(builderName).then(function(resultsLocations) {
         keyList = resultsLocations;
         continueWalk();
     });
 }
 
-results.regressionRangeForFailure = function(builderName, testName, callback)
-{
-    var oldestFailingRevision = 0;
-    var newestPassingRevision = 0;
+results.regressionRangeForFailure = function(builderName, testName) {
+    return new Promise(function(resolve, reject) {
+        var oldestFailingRevision = 0;
+        var newestPassingRevision = 0;
 
-    walkHistory(builderName, testName, function(revision, resultNode) {
-        if (!revision) {
-            callback(oldestFailingRevision, newestPassingRevision);
+        walkHistory(builderName, testName, function(revision, resultNode) {
+            if (!revision) {
+                resolve([oldestFailingRevision, newestPassingRevision]);
+                return false;
+            }
+            if (!resultNode) {
+                newestPassingRevision = revision;
+                resolve([oldestFailingRevision, newestPassingRevision]);
+                return false;
+            }
+            if (isUnexpectedFailure(resultNode)) {
+                oldestFailingRevision = revision;
+                return true;
+            }
+            if (!oldestFailingRevision)
+                return true;  // We need to keep looking for a failing revision.
+            newestPassingRevision = revision;
+            resolve([oldestFailingRevision, newestPassingRevision]);
             return false;
-        }
-        if (!resultNode) {
-            newestPassingRevision = revision;
-            callback(oldestFailingRevision, newestPassingRevision);
-            return false;
-        }
-        if (isUnexpectedFailure(resultNode)) {
-            oldestFailingRevision = revision;
-            return true;
-        }
-        if (!oldestFailingRevision)
-            return true;  // We need to keep looking for a failing revision.
-        newestPassingRevision = revision;
-        callback(oldestFailingRevision, newestPassingRevision);
-        return false;
+        });
     });
 };
 
 function mergeRegressionRanges(regressionRanges)
 {
     var mergedRange = {};
 
     mergedRange.oldestFailingRevision = 0;
     mergedRange.newestPassingRevision = 0;
 
     $.each(regressionRanges, function(builderName, range) {
         if (!range.oldestFailingRevision && !range.newestPassingRevision)
             return
 
         if (!mergedRange.oldestFailingRevision)
             mergedRange.oldestFailingRevision = range.oldestFailingRevision;
         if (!mergedRange.newestPassingRevision)
             mergedRange.newestPassingRevision = range.newestPassingRevision;
 
         if (range.oldestFailingRevision && range.oldestFailingRevision < mergedRange.oldestFailingRevision)
             mergedRange.oldestFailingRevision = range.oldestFailingRevision;
         if (range.newestPassingRevision > mergedRange.newestPassingRevision)
             mergedRange.newestPassingRevision = range.newestPassingRevision;
     });
 
     return mergedRange;
 }
 
-results.unifyRegressionRanges = function(builderNameList, testName, callback)
-{
+results.unifyRegressionRanges = function(builderNameList, testName) {
     var regressionRanges = {};
 
-    var tracker = new base.RequestTracker(builderNameList.length, function() {
+    var rangePromises = [];
+    $.each(builderNameList, function(index, builderName) {
+        rangePromises.push(results.regressionRangeForFailure(builderName, testName)
+                           .then(function(result) {
+                               var oldestFailingRevision = result[0];
+                               var newestPassingRevision = result[1];
+                               var range = {};
+                               range.oldestFailingRevision = oldestFailingRevision;
+                               range.newestPassingRevision = newestPassingRevision;
+                               regressionRanges[builderName] = range;
+                           }));
+    });
+    return Promise.all(rangePromises).then(function() {
         var mergedRange = mergeRegressionRanges(regressionRanges);
-        callback(mergedRange.oldestFailingRevision, mergedRange.newestPassingRevision);
-    });
-
-    $.each(builderNameList, function(index, builderName) {
-        results.regressionRangeForFailure(builderName, testName, function(oldestFailingRevision, newestPassingRevision) {
-            var range = {};
-            range.oldestFailingRevision = oldestFailingRevision;
-            range.newestPassingRevision = newestPassingRevision;
-            regressionRanges[builderName] = range;
-            tracker.requestComplete();
-        });
+        return [mergedRange.oldestFailingRevision, mergedRange.newestPassingRevision];
     });
 };
 
 results.resultNodeForTest = function(resultsTree, testName)
 {
     var testNamePath = testName.split('/');
     var currentNode = resultsTree['tests'];
     $.each(testNamePath, function(index, segmentName) {
         if (!currentNode)
             return;
@@ skipping 26 matching lines @@
 {
     var sortedURLs = [];
     $.each(kPreferredSuffixOrder, function(i, suffix) {
         $.each(urls, function(j, url) {
             if (!base.endsWith(url, suffix))
                 return;
             sortedURLs.push(url);
         });
     });
     if (sortedURLs.length != urls.length)
-        throw "sortResultURLsBySuffix failed to return the same number of URLs."
+        throw "sortResultURLsBySuffix failed to return the same number of URLs.";
     return sortedURLs;
 }
 
-results.fetchResultsURLs = function(failureInfo, callback)
+results.fetchResultsURLs = function(failureInfo)
 {
     var testNameStem = base.trimExtension(failureInfo.testName);
     var urlStem = resultsDirectoryURL(failureInfo.builderName);
 
     var suffixList = possibleSuffixListFor(failureInfo.failureTypeList);
     var resultURLs = [];
-    var tracker = new base.RequestTracker(suffixList.length, function() {
-        callback(sortResultURLsBySuffix(resultURLs));
-    });
+    var probePromises = [];
     $.each(suffixList, function(index, suffix) {
         var url = urlStem + testNameStem + suffix;
-        net.probe(url).then(
+        probePromises.push(net.probe(url).then(
             function() {
                 resultURLs.push(url);
-                tracker.requestComplete();
             },
-            function() {
-                tracker.requestComplete();
-            });
+            function() {}));
+    });
+    return Promise.all(probePromises).then(function() {
+        return sortResultURLsBySuffix(resultURLs);
     });
 };
 
-results.fetchResultsByBuilder = function(builderNameList, callback)
+results.fetchResultsByBuilder = function(builderNameList)
 {
     var resultsByBuilder = {};
-    var tracker = new base.RequestTracker(builderNameList.length, function() {
-        callback(resultsByBuilder);
-    });
+    var fetchPromises = [];
     $.each(builderNameList, function(index, builderName) {
         var resultsURL = resultsSummaryURL(builderName);
-        net.jsonp(resultsURL).then(function(resultsTree) {
+        fetchPromises.push(net.jsonp(resultsURL).then(function(resultsTree) {
             resultsByBuilder[builderName] = resultsTree;
-            tracker.requestComplete();
-        });
+        }));
+    });
+    return Promise.all(fetchPromises).then(function() {
+        return resultsByBuilder;
     });
 };
 
 })();