Added support for improvement_direction to relevant values, which is propogated to chartjson.

tools/perf/metrics/timeline.py

 # 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.
 import collections
 from telemetry.util.statistics import DivideIfPossibleOrZero
 
 from telemetry.web_perf.metrics import timeline_based_metric
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
 
 
 class LoadTimesTimelineMetric(timeline_based_metric.TimelineBasedMetric):
   def __init__(self):
     super(LoadTimesTimelineMetric, self).__init__()
     self.report_main_thread_only = True
 
   def AddResults(self, model, renderer_thread, interaction_records, results):
     assert model
@@ skipping 22 matching lines @@
       for event_name, event_group in events_by_name.iteritems():
         times = [event.self_time for event in event_group]
         total = sum(times)
         biggest_jank = max(times)
 
         # Results objects cannot contain the '.' character, so remove that here.
         sanitized_event_name = event_name.replace('.', '_')
 
         full_name = thread_name + '|' + sanitized_event_name
         results.AddValue(scalar.ScalarValue(
-            results.current_page, full_name, 'ms', total))
+            results.current_page, full_name, 'ms', total,
+            improvement_direction=improvement_direction.DOWN))
         results.AddValue(scalar.ScalarValue(
-            results.current_page, full_name + '_max', 'ms', biggest_jank))
+            results.current_page, full_name + '_max', 'ms', biggest_jank,
+            improvement_direction=improvement_direction.DOWN))
         results.AddValue(scalar.ScalarValue(
-            results.current_page, full_name + '_avg', 'ms', total / len(times)))
+            results.current_page, full_name + '_avg', 'ms', total / len(times),
+            improvement_direction=improvement_direction.DOWN))
 
     for counter_name, counter in renderer_process.counters.iteritems():
       total = sum(counter.totals)
 
       # Results objects cannot contain the '.' character, so remove that here.
       sanitized_counter_name = counter_name.replace('.', '_')
 
       results.AddValue(scalar.ScalarValue(
-          results.current_page, sanitized_counter_name, 'count', total))
+          results.current_page, sanitized_counter_name, 'count', total,
+          improvement_direction=improvement_direction.DOWN))
       results.AddValue(scalar.ScalarValue(
           results.current_page, sanitized_counter_name + '_avg', 'count',
-          total / float(len(counter.totals))))
+          total / float(len(counter.totals)),
+          improvement_direction=improvement_direction.DOWN))
 
 # We want to generate a consistant picture of our thread usage, despite
 # having several process configurations (in-proc-gpu/single-proc).
 # Since we can't isolate renderer threads in single-process mode, we
 # always sum renderer-process threads' times. We also sum all io-threads
 # for simplicity.
 TimelineThreadCategories =  {
   "Chrome_InProcGpuThread": "GPU",
   "CrGpuMain"             : "GPU",
   "AsyncTransferThread"   : "GPU_transfer",
@@ skipping 111 matching lines @@
     self.all_slices.extend(self.SlicesInActions(thread.all_slices))
     self.toplevel_slices.extend(self.SlicesInActions(thread.toplevel_slices))
 
   # Currently we report cpu-time per frame, tasks per frame, and possibly
   # the mean frame (if there is a trace specified to find it).
   def AddResults(self, num_frames, results):
     cpu_per_frame = Rate(self.cpu_time, num_frames)
     tasks_per_frame = Rate(len(self.toplevel_slices), num_frames)
     results.AddValue(scalar.ScalarValue(
         results.current_page, ThreadCpuTimeResultName(self.name),
-        'ms', cpu_per_frame))
+        'ms', cpu_per_frame, improvement_direction=improvement_direction.DOWN))
     results.AddValue(scalar.ScalarValue(
         results.current_page, ThreadTasksResultName(self.name),
-        'tasks', tasks_per_frame))
+        'tasks', tasks_per_frame,
+        improvement_direction=improvement_direction.DOWN))
     # Report mean frame time if this is the thread we are using for normalizing
     # other results. We could report other frame rates (eg. renderer_main) but
     # this might get confusing.
     if self.name == FrameTraceThreadName:
       num_frames = self.CountTracesWithName(FrameTraceName)
       mean_frame_time = Rate(self.all_action_time, num_frames)
       results.AddValue(scalar.ScalarValue(
           results.current_page, ThreadMeanFrameTimeResultName(self.name),
-          'ms', mean_frame_time))
+          'ms', mean_frame_time,
+          improvement_direction=improvement_direction.DOWN))
 
   def AddDetailedResults(self, num_frames, results):
     slices_by_category = collections.defaultdict(list)
     for s in self.all_slices:
       slices_by_category[s.category].append(s)
     all_self_times = []
     for category, slices_in_category in slices_by_category.iteritems():
       self_time = sum([x.self_time for x in slices_in_category])
       all_self_times.append(self_time)
       self_time_result = (float(self_time) / num_frames) if num_frames else 0
       results.AddValue(scalar.ScalarValue(
           results.current_page, ThreadDetailResultName(self.name, category),
-          'ms', self_time_result))
+          'ms', self_time_result,
+          improvement_direction=improvement_direction.DOWN))
     all_measured_time = sum(all_self_times)
     idle_time = max(0, self.all_action_time - all_measured_time)
     idle_time_result = (float(idle_time) / num_frames) if num_frames else 0
     results.AddValue(scalar.ScalarValue(
         results.current_page, ThreadDetailResultName(self.name, "idle"),
-        'ms', idle_time_result))
+        'ms', idle_time_result,
+        improvement_direction=improvement_direction.DOWN))
 
   def CountTracesWithName(self, substring):
     count = 0
     for event in self.all_slices:
       if substring in event.name:
         count += 1
     return count
 
 class ThreadTimesTimelineMetric(timeline_based_metric.TimelineBasedMetric):
   def __init__(self):
@@ skipping 28 matching lines @@
     num_frames = frame_rate_thread.CountTracesWithName(FrameTraceName)
 
     # Report the desired results and details.
     for thread_results in thread_category_results.values():
       if thread_results.name in self.results_to_report:
         thread_results.AddResults(num_frames, results)
       # TOOD(nduca): When generic results objects are done, this special case
       # can be replaced with a generic UI feature.
       if thread_results.name in self.details_to_report:
         thread_results.AddDetailedResults(num_frames, results)