Reland "Fix buildbot console view in order_by_time mode"

third_party/buildbot_8_4p1/buildbot/status/web/console.py

 # This file is part of Buildbot.  Buildbot is free software: you can
 # redistribute it and/or modify it under the terms of the GNU General Public
 # License as published by the Free Software Foundation, version 2.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 # details.
 #
 # You should have received a copy of the GNU General Public License along with
@@ skipping 140 matching lines @@
         self.date = change.getTime()
         self.revlink = getattr(change, 'revlink', None)
         self.when = change.when
         self.repository = change.repository
         self.project = change.project
 
 
 class DevBuild:
     """Helper class that contains all the information we need for a build."""
 
-    def __init__(self, revision, build, details, inProgressResults=None):
+    def __init__(self, revision, build, details, inProgressResults=None,
+                 revisions=[]):
         self.revision = revision
         self.results =  build.getResults()
         self.number = build.getNumber()
         self.isFinished = build.isFinished()
         self.text = build.getText()
         self.eta = build.getETA()
         self.details = details
         self.when = build.getTimes()[0]
         self.source = build.getSourceStamp()
         self.inProgressResults = inProgressResults
+        for rev in revisions:
+          if rev.revision == revision:
+            self.when = rev.when
+            break
 
 
 class ConsoleStatusResource(HtmlResource):
     """Main console class. It displays a user-oriented status page.
     Every change is a line in the page, and it shows the result of the first
     build with this change for each slave."""
 
     def __init__(self, orderByTime=False, repository=None,
                  builder_filter_fn=lambda builderName: True):
         HtmlResource.__init__(self)
@@ skipping 127 matching lines @@
                         logurl = request.childLink(
                           "../builders/%s/builds/%s/steps/%s/logs/%s" %
                             (urllib.quote(builderName, safe=''),
                              build.getNumber(),
                              urllib.quote(name, safe=''),
                              urllib.quote(logname, safe='')))
                         logs.append(dict(url=logurl, name=logname))
         return details
 
     def getBuildsForRevision(self, request, builder, builderName, lastRevision,
-                             numBuilds, debugInfo):
+                             numBuilds, debugInfo, revisions):
         """Return the list of all the builds for a given builder that we will
         need to be able to display the console page. We start by the most recent
         build, and we go down until we find a build that was built prior to the
         last change we are interested in."""
 
         revision = lastRevision
 
         builds = []
         build = self.getHeadBuild(builder)
         number = 0
@@ skipping 20 matching lines @@
             except:
                 pass
 
             # We ignore all builds that don't have last revisions.
             # TODO(nsylvain): If the build is over, maybe it was a problem
             # with the update source step. We need to find a way to tell the
             # user that his change might have broken the source update.
             if got_rev and got_rev != -1:
                 details = self.getBuildDetails(request, builderName, build)
                 devBuild = DevBuild(got_rev, build, details,
-                                    getInProgressResults(build))
+                                    getInProgressResults(build), revisions)
                 builds.append(devBuild)
 
                 # Now break if we have enough builds.
                 current_revision = self.getChangeForBuild(
                     build, revision)
                 if self.comparator.isRevisionEarlier(
                     devBuild, current_revision):
                     break
 
             build = build.getPreviousBuild()
 
         return builds
 
     def getChangeForBuild(self, build, revision):
         if not build or not build.getChanges(): # Forced build
             return DevBuild(revision, build, None)
 
         for change in build.getChanges():
             if change.revision == revision:
                 return change
 
         # No matching change, return the last change in build.
         changes = list(build.getChanges())
         changes.sort(key=self.comparator.getSortingKey())
         return changes[-1]
 
     def getAllBuildsForRevision(self, status, request, lastRevision, numBuilds,
-                                categories, builders, debugInfo):
+                                categories, builders, debugInfo, revisions):
         """Returns a dictionary of builds we need to inspect to be able to
         display the console page. The key is the builder name, and the value is
         an array of build we care about. We also returns a dictionary of
         builders we care about. The key is it's category.
 
         lastRevision is the last revision we want to display in the page.
         categories is a list of categories to display. It is coming from the
             HTTP GET parameters.
         builders is a list of builders to display. It is coming from the HTTP
             GET parameters.
@@ skipping 30 matching lines @@
                 builderList[category] = []
 
             # Append this builder to the dictionary of builders.
             builderList[category].append(builderName)
             # Set the list of builds for this builder.
             allBuilds[builderName] = self.getBuildsForRevision(request,
                                                                builder,
                                                                builderName,
                                                                lastRevision,
                                                                numBuilds,
-                                                               debugInfo)
+                                                               debugInfo,
+                                                               revisions)
 
         return (builderList, allBuilds)
 
 
     ##
     ## Display functions
     ##
 
     def displayCategories(self, builderList, debugInfo):
         """Display the top category line."""
@@ skipping 343 matching lines @@
             if revisions:
                 lastRevision = revisions[len(revisions) - 1].revision
                 debugInfo["last_revision"] = lastRevision
 
                 (builderList, allBuilds) = self.getAllBuildsForRevision(status,
                                                     request,
                                                     lastRevision,
                                                     numBuilds,
                                                     categories,
                                                     builders,
-                                                    debugInfo)
+                                                    debugInfo,
+                                                    revisions)
 
             debugInfo["added_blocks"] = 0
             debugInfo["from_cache"] = 0
 
             if request.args.get("display_cache", None):
                 data = ""
                 data += "\nGlobal Cache\n"
                 data += self.cache.display()
                 return data
 
@@ skipping 53 matching lines @@
 
     def isValidRevision(self, revision):
         try:
             int(revision)
             return True
         except:
             return False
 
     def getSortingKey(self):
         return operator.attrgetter('revision')