Move the trace sorting from the JS up to the Python, matching what's done for...

tools/buildbot/scripts/master/log_parser/process_log.py

 #!/usr/bin/python
 # Copyright (c) 2006-2008 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.
 
 """Defines various log processors used by buildbot steps.
 
 Current approach is to set an instance of log processor in
 the ProcessLogTestStep implementation and it will call process()
 method upon completion with full data from process stdio.
@@ skipping 276 matching lines @@
     self.traces = {}
 
   def IsImportant(self):
     """A graph is 'important' if any of its traces is."""
     for trace in self.traces.itervalues():
       if trace.important:
         return True
     return False
 
 
-class JSONGraphEncoder(simplejson.JSONEncoder):
-  def default(self, obj):
-    if isinstance(obj, Graph):
-      return {'units': obj.units, 'traces': obj.traces}
-    if isinstance(obj, Trace):
-      # NB: We do not encode the 'important' value: the plot doesn't need it.
-      return [obj.value, obj.stddev]
-    return simplejson.JSONEncoder.default(self, obj)
-
-
 class GraphingLogProcessor(PerformanceLogProcessor):
   """Parent class for any log processor expecting standard data to be graphed.
 
   The log will be parsed looking for any lines of the form
     <*>RESULT <graph_name>: <trace_name>= <value> <units>
   or
     <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...] <units>
   or
     <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>} <units>
   For example,
@@ skipping 87 matching lines @@
     This method may be overridden by subclasses wanting a different standard
     deviation calcuation (or some other sort of error value entirely).
 
     Args:
       value_list: the list of values to use in the calculation
       trace_name: the trace that produced the data (not used in the base
           implementation, but subclasses may use it)
     """
     return chromium_utils.FilteredMeanAndStandardDeviation(value_list)
 
+  def __BuildSummaryJSON(self, graph):
+    """Sorts the traces and returns a summary JSON encoding of the graph.
+
+    Although JS objects are not ordered, according to the spec, in practice
+    everyone iterates in order, since not doing so is a compatibility problem.
+    So we'll count on it here and produce an ordered list of traces.
+
+    But since Python dicts are *not* ordered, we'll need to construct the JSON
+    manually so we don't lose the trace order.
+    """
+    traces = []
+    remaining_traces = graph.traces.copy()
+
+    def AddTrace(trace_name):
+      if trace_name in remaining_traces:
+        traces.append(trace_name)
+        del remaining_traces[trace_name]
+
+    # First pull out any important traces in alphabetical order, and their
+    # _ref traces even if not important.
+    keys = [x for x in graph.traces.keys() if graph.traces[x].important]
+    keys.sort()
+    for name in keys:
+      AddTrace(name)
+      AddTrace(name + "_ref")
+
+    # Now append any other traces that have corresponding _ref traces, in
+    # alphabetical order.
+    keys = [x for x in graph.traces.keys() if x + "_ref" in remaining_traces]
+    keys.sort()
+    for name in keys:
+      AddTrace(name)
+      AddTrace(name + "_ref")
+
+    # Finally, append any remaining traces, in alphabetical order.
+    keys = remaining_traces.keys()
+    keys.sort()
+    traces.extend(keys)
+
+    # Now build the JSON.
+    trace_json = ', '.join(['"%s": [%s, %s]' %
+        (x, graph.traces[x].value, graph.traces[x].stddev) for x in traces])
+    return '{"traces": {%s}, "rev": "%s"}' % (trace_json, self._revision)
+
   def __CreateSummaryOutput(self):
     """Write the summary data file and collect the waterfall display text.
 
     The summary file contains JSON-encoded data.
 
     The waterfall contains lines for each important trace, in the form
       tracename: value< (refvalue)>
     """
     for graph_name, graph in self._graphs.iteritems():
       # Write a line in the applicable summary file for each graph.
       if  self._ShouldWriteResults():
         filename = os.path.join(self._output_dir,
                                 "%s-summary.dat" % graph_name)
-        json = simplejson.dumps({'rev': self._revision,
-                                 'traces': graph.traces}, cls=JSONGraphEncoder)
-        Prepend(filename, json + "\n")
+        Prepend(filename, self.__BuildSummaryJSON(graph) + "\n")
 
       # Add a line to the waterfall for each important trace.
       for trace_name, trace in graph.traces.iteritems():
         if trace_name.endswith("_ref"):
           continue
         if trace.important:
           display = "%s: %s" % (trace_name, FormatHumanReadable(trace.value))
           if graph.traces.get(trace_name + '_ref'):
             display += " (%s)" % FormatHumanReadable(
                                  graph.traces[trace_name + '_ref'].value)
@@ skipping 110 matching lines @@
            FormatFloat(mean),
            FormatFloat(stddev),
            self._JoinWithSpacesAndNewLine(times)))
 
     filename = os.path.join(self._output_dir,
                             '%s_%s.dat' % (self._revision, trace_name))
     file = open(filename, 'w')
     file.write(''.join(file_data))
     file.close()
     os.chmod(filename, READABLE_FILE_PERMISSIONS)