Move commit list and builder latest revisions up to ct-unexpected-failures

Tools/GardeningServer/ui/ct-builder-grid.html

 <!--
 Copyright 2014 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.
 -->
 
 <link rel="import" href="ct-builder.html">
 
 <!-- Table of failure types, listing the failing builders for each type. -->
-<polymer-element name="ct-builder-grid" attributes="failures">
+<polymer-element name="ct-builder-grid" attributes="failures builderLatestRevisions">
   <template>
     <style>
       table {
         border-collapse: collapse;
         font-size: 11px;
         table-layout: fixed;
         width: 350px;
       }
 
       tbody td:first-child {
@@ skipping 71 matching lines @@
               </template>
             </td>
           </tr>
         </template>
       </tbody>
     </table>
   </template>
   <script>
     Polymer({
       failures: [],
+      builderLatestRevisions: {},
       resultTypes: {},
 
       keys: function(obj) {
         return Object.keys(obj).sort();
       },
 
       resultTypeKeys: function(obj) {
         // Get the keys, but the BUILDING type should be last.
         var keys = this.keys(obj);
         var index = keys.indexOf('BUILDING');
         if (index != -1) {
           var buildingResult = keys.splice(index, 1);
           keys.push(buildingResult[0]);
         }
         return keys;
       },
 
       failuresChanged: function() {
         // Create a set of builders for each result type (e.g., text, crash).
         this.resultTypes = {};
         var passingRevisions = [];
         this.failures.forEach(function(failure) {
           passingRevisions.push(failure.newestPassingRevision);
           var results = failure.resultNodesByBuilder;
-          Object.keys(results, (function(builderName) {
-            var result = results[builderName];
+          Object.keys(results, (function(builder) {
+            var result = results[builder];
             if (!result.is_unexpected)
               return;
 
             if (!Object.has(this.resultTypes, result.actual))
               this.resultTypes[result.actual] = {};
-            this.resultTypes[result.actual][builderName] =
-                config.builders[builderName];
+            this.resultTypes[result.actual][builder] =
+                config.builders[builder];
           }).bind(this));
         }, this);
 
         var buildingType = this._getBuilding(passingRevisions);
         if (!Object.isEmpty(buildingType))
             this.resultTypes['BUILDING'] = buildingType;
       },
 
+      _buildersInFlightForRevision: function(revision) {
+        return Object.keys(this.builderLatestRevisions).filter(function(builder) {
+          // FIXME: This should look at all chromium/v8/etc revisions as well.
+          // Is this concept of "building" builders even useful as is?
+          return parseInt(this.builderLatestRevisions[builder].blink, 10) < revision;
+        }.bind(this));
+      },
+
       _getBuilding: function(revisions) {
         var building = {};
-        var builderNames = [];
+        var builders = [];
         revisions.unique().forEach(function(revision) {
-          builderNames.push.apply(builderNames,
-              Object.keys(model.buildersInFlightForRevision(revision + 1)));
+          builders.push.apply(builders, this._buildersInFlightForRevision(revision + 1));
+        }.bind(this));
+
+        builders.unique().forEach(function(builder) {
+          if (!config.builders[builder])
+            return;
+          building[builder] = {'debug': config.builders[builder].debug};
         });
-        builderNames.unique().forEach(function(builderName) {
-          if (!config.builders[builderName])
-            return;
-          building[builderName] =
-              {'debug': config.builders[builderName].debug};
-        });
+
         return building;
       },
     });
   </script>
 </polymer-element>