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

Tools/GardeningServer/scripts/model.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 81 matching lines @@
 
 model.takeExpectationUpdateQueue = function()
 {
     var queue = model.state.expectationsUpdateQueue;
     model.state.expectationsUpdateQueue = [];
     return queue;
 };
 
 var g_commitIndex = {};
 
-model.updateRecentCommits = function(callback)
+model.updateRecentCommits = function()
 {
-    trac.recentCommitData('trunk', kCommitLogLength, function(commitDataList) {
+    return trac.recentCommitData('trunk', kCommitLogLength).then(function(commitDataList) {
         model.state.recentCommits = commitDataList;
         updateCommitIndex();
         findAndMarkRevertedRevisions(model.state.recentCommits);
-        callback();
     });
 };
 
 function updateCommitIndex()
 {
     model.state.recentCommits.forEach(function(commitData) {
         g_commitIndex[commitData.revision] = commitData;
     });
 }
 
@@ skipping 15 matching lines @@
         var results = model.state.resultsByBuilder[builderName];
         if (parseInt(results.blink_revision) < revision)
             builders[builderName] = { actual: 'BUILDING' };
     });
     return builders;
 };
 
 model.latestRevision = function()
 {
     return model.state.recentCommits[0].revision;
-}
+};
 
 model.latestRevisionWithNoBuildersInFlight = function()
 {
     var revision = 0;
     Object.keys(model.state.resultsByBuilder).forEach(function(builderName) {
         var results = model.state.resultsByBuilder[builderName];
         if (!results.blink_revision)
             return;
         var testedRevision = parseInt(results.blink_revision);
         revision = revision ? Math.min(revision, testedRevision) : testedRevision;
     });
     return revision;
 }
 
 model.latestRevisionByBuilder = function()
 {
     var revision = {};
     Object.keys(model.state.resultsByBuilder).forEach(function(builderName) {
         revision[builderName] = model.state.resultsByBuilder[builderName].blink_revision;
     });
     return revision;
 }
 
-model.updateResultsByBuilder = function(callback)
+model.updateResultsByBuilder = function()
 {
-    results.fetchResultsByBuilder(Object.keys(config.builders), function(resultsByBuilder) {
+    return results.fetchResultsByBuilder(Object.keys(config.builders)).then(function(resultsByBuilder) {
         model.state.resultsByBuilder = resultsByBuilder;
-        callback();
     });
 };
 
-model.analyzeUnexpectedFailures = function(callback, completionCallback)
+// failureCallback is called multiple times: once for each failure
+model.analyzeUnexpectedFailures = function(failureCallback)
 {
     var unexpectedFailures = results.unexpectedFailuresByTest(model.state.resultsByBuilder);
 
     $.each(model.state.failureAnalysisByTest, function(testName, failureAnalysis) {
         if (!(testName in unexpectedFailures))
             delete model.state.failureAnalysisByTest[testName];
     });
 
-    var tracker = new base.RequestTracker(Object.keys(unexpectedFailures).length, completionCallback);
+    var failurePromises = [];
     $.each(unexpectedFailures, function(testName, resultNodesByBuilder) {
         var builderNameList = Object.keys(resultNodesByBuilder);
-        results.unifyRegressionRanges(builderNameList, testName, function(oldestFailingRevision, newestPassingRevision) {
+        failurePromises.push(results.unifyRegressionRanges(builderNameList, testName).then(function(result) {
+            var oldestFailingRevision = result[0];
+            var newestPassingRevision = result[1];
             var failureAnalysis = {
                 'testName': testName,
                 'resultNodesByBuilder': resultNodesByBuilder,
                 'oldestFailingRevision': oldestFailingRevision,
                 'newestPassingRevision': newestPassingRevision,
             };
 
             heuristicallyNarrowRegressionRange(failureAnalysis);
 
             var previousFailureAnalysis = model.state.failureAnalysisByTest[testName];
             if (previousFailureAnalysis
                 && previousFailureAnalysis.oldestFailingRevision <= failureAnalysis.oldestFailingRevision
                 && previousFailureAnalysis.newestPassingRevision >= failureAnalysis.newestPassingRevision) {
                 failureAnalysis.oldestFailingRevision = previousFailureAnalysis.oldestFailingRevision;
                 failureAnalysis.newestPassingRevision = previousFailureAnalysis.newestPassingRevision;
             }
 
             model.state.failureAnalysisByTest[testName] = failureAnalysis;
-            
-            callback(failureAnalysis);
-            tracker.requestComplete();
-        });
+
+            failureCallback(failureAnalysis);
+        }));
     });
+    return Promise.all(failurePromises);
 };
 
 model.unexpectedFailureInfoForTestName = function(testName)
 {
     var resultsByTest = results.unexpectedFailuresByTest(model.state.resultsByBuilder);
 
     return Object.keys(resultsByTest[testName]).map(function(builderName) {
         return results.failureInfoForTestAndBuilder(resultsByTest, testName, builderName);
     });
 };
 
-model.analyzeexpectedFailures = function(callback)
+// failureCallback is called multiple times: once for each failure
+model.analyzeexpectedFailures = function(failureCallback)
 {
     var expectedFailures = results.expectedFailuresByTest(model.state.resultsByBuilder);
     $.each(expectedFailures, function(testName, resultNodesByBuilder) {
         var failureAnalysis = {
             'testName': testName,
             'resultNodesByBuilder': resultNodesByBuilder,
         };
 
         // FIXME: Consider looking at the history to see how long this test
         // has been failing.
 
-        callback(failureAnalysis);
+        failureCallback(failureAnalysis);
     });
 };
 
 })();