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

tools/perf/metrics/power.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 time
 
 from metrics import Metric
 from telemetry.core.platform import process_statistic_timeline_data
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
 
 
 class PowerMetric(Metric):
   """A metric for measuring power usage."""
 
   # System power draw while idle.
   _quiescent_power_draw_mwh = 0
 
   def __init__(self, platform, quiescent_measurement_time_s=0):
@@ skipping 86 matching lines @@
     if (PowerMetric._quiescent_power_draw_mwh and
         application_energy_consumption_mwh is None and
         total_energy_consumption_mwh is not None):
       application_energy_consumption_mwh = max(
           total_energy_consumption_mwh - PowerMetric._quiescent_power_draw_mwh,
           0)
 
     if total_energy_consumption_mwh is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'energy_consumption_mwh', 'mWh',
-          total_energy_consumption_mwh))
+          total_energy_consumption_mwh,
+          improvement_direction=improvement_direction.DOWN))
 
     if application_energy_consumption_mwh is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'application_energy_consumption_mwh', 'mWh',
-          application_energy_consumption_mwh))
+          application_energy_consumption_mwh,
+          improvement_direction=improvement_direction.DOWN))
 
     component_utilization = self._results.get('component_utilization', {})
     # GPU Frequency.
     gpu_power = component_utilization.get('gpu', {})
     gpu_freq_hz = gpu_power.get('average_frequency_hz')
     if gpu_freq_hz is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'gpu_average_frequency_hz', 'hz', gpu_freq_hz,
-          important=False))
+          important=False, improvement_direction=improvement_direction.DOWN))
 
     # Add idle wakeup numbers for all processes.
     for (process_type, stats) in self._results.get('cpu_stats', {}).items():
       trace_name_for_process = 'idle_wakeups_%s' % (process_type.lower())
       results.AddValue(scalar.ScalarValue(
           results.current_page, trace_name_for_process, 'count', stats,
-          important=False))
+          important=False, improvement_direction=improvement_direction.DOWN))
 
     # Add temperature measurements.
     whole_package_utilization = component_utilization.get('whole_package', {})
     board_temperature_c = whole_package_utilization.get('average_temperature_c')
     if board_temperature_c is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'board_temperature', 'celsius',
-          board_temperature_c, important=False))
+          board_temperature_c, important=False,
+          improvement_direction=improvement_direction.DOWN))
 
     # Add CPU frequency measurements.
     frequency_hz = whole_package_utilization.get('frequency_percent')
     if frequency_hz is not None:
       frequency_sum = 0.0
       for freq, percent in frequency_hz.iteritems():
         frequency_sum += freq * (percent / 100.0)
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'cpu_average_frequency_hz', 'Hz',
-          frequency_sum, important=False))
+          frequency_sum, important=False,
+          improvement_direction=improvement_direction.DOWN))
 
     # Add CPU c-state residency measurements.
     cstate_percent = whole_package_utilization.get('cstate_residency_percent')
     if cstate_percent is not None:
       for state, percent in cstate_percent.iteritems():
         results.AddValue(scalar.ScalarValue(
             results.current_page, 'cpu_cstate_%s_residency_percent' % state,
-            '%', percent, important=False))
+            '%', percent, important=False,
+            improvement_direction=improvement_direction.DOWN))
 
     self._results = None
 
 def _SubtractCpuStats(cpu_stats, start_cpu_stats):
   """Computes number of idle wakeups that occurred over measurement period.
 
   Each of the two cpu_stats arguments is a dict as returned by the
   Browser.cpu_stats call.
 
   Returns:
@@ skipping 13 matching lines @@
       continue
 
     assert isinstance(cpu_stats[process_type]['IdleWakeupCount'],
         process_statistic_timeline_data.IdleWakeupTimelineData)
     idle_wakeup_delta = (cpu_stats[process_type]['IdleWakeupCount'] -
                         start_cpu_stats[process_type]['IdleWakeupCount'])
     cpu_delta[process_type] = idle_wakeup_delta.total_sum()
     total = total + cpu_delta[process_type]
   cpu_delta['Total'] = total
   return cpu_delta