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

tools/perf/benchmarks/service_worker.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
 import page_sets
 import re
 
 from measurements import timeline_controller
 from metrics import speedindex
 from telemetry import benchmark
 from telemetry.core import util
 from telemetry.page import page_test
 from telemetry.timeline import async_slice as async_slice_module
 from telemetry.timeline import slice as slice_module
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
 
 
 class _ServiceWorkerTimelineMetric(object):
   def AddResultsOfCounters(self, process, counter_regex_string, results):
     counter_filter = re.compile(counter_regex_string)
     for counter_name, counter in process.counters.iteritems():
       if not counter_filter.search(counter_name):
         continue
 
       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))
 
   def AddResultsOfEvents(
       self, process, thread_regex_string, event_regex_string, results):
     thread_filter = re.compile(thread_regex_string)
     event_filter = re.compile(event_regex_string)
 
     for thread in process.threads.itervalues():
       thread_name = thread.name.replace('/', '_')
       if not thread_filter.search(thread_name):
         continue
@@ skipping 22 matching lines @@
 
   def _AddResultOfEvent(self, thread_name, event_name, times, results):
     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))
 
 
 class _ServiceWorkerMeasurement(page_test.PageTest):
   """Measure Speed Index and TRACE_EVENTs"""
 
   def __init__(self):
     super(_ServiceWorkerMeasurement, self).__init__(
         action_name_to_run='RunPageInteractions')
     self._timeline_controller = timeline_controller.TimelineController()
     self._speed_index = speedindex.SpeedIndexMetric()
@@ skipping 60 matching lines @@
     self._timeline_controller.Start(tab)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     tab.WaitForJavaScriptExpression('window.done', 40)
     self._timeline_controller.Stop(tab, results)
 
     # Measure JavaScript-land
     json = tab.EvaluateJavaScript('window.results || {}')
     for key, value in json.iteritems():
       results.AddValue(scalar.ScalarValue(
-          results.current_page, key, value['units'], value['value']))
+          results.current_page, key, value['units'], value['value'],
+          improvement_direction=improvement_direction.DOWN))
 
     # Retrieve TRACE_EVENTs
     timeline_metric = _ServiceWorkerTimelineMetric()
     browser_process = self._timeline_controller.model.browser_process
     filter_text = '(RegisterServiceWorker|'\
                   'UnregisterServiceWorker|'\
                   'ProcessAllocate|'\
                   'FindRegistrationForDocument|'\
                   'DispatchFetchEvent)'
     timeline_metric.AddResultsOfEvents(
@@ skipping 12 matching lines @@
   """This test measures the performance of pages using ServiceWorker.
 
   As a page set, two benchamrk pages (many registration, many concurrent
   fetching) and one application (Trained-to-thrill:
   https://jakearchibald.github.io/trained-to-thrill/) are included. Execution
   time of these pages will be shown as Speed Index, and TRACE_EVENTs are
   subsidiary information to know more detail performance regression.
   """
   test = _ServiceWorkerMicroBenchmarkMeasurement
   page_set = page_sets.ServiceWorkerMicroBenchmarkPageSet