Change PageTest.WillStartBrowser to depend on platform instead of browser object as it would not ha…

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 scalar
 
 
 class PowerMetric(Metric):
   """A metric for measuring power usage."""
 
   # System power draw while idle.
   _quiescent_power_draw_mwh = 0
 
-  def __init__(self, browser, quiescent_measurement_time_s=0):
+  def __init__(self, platform, quiescent_measurement_time_s=0):
     """PowerMetric Constructor.
 
     Args:
-        browser: browser object to use.
+        platform: platform object to use.
         quiescent_measurement_time_s: time to measure quiescent power,
             in seconds. 0 means don't measure quiescent power."""
     super(PowerMetric, self).__init__()
-    self._browser = browser
+    self._browser = None
+    self._platform = platform
     self._running = False
     self._starting_cpu_stats = None
     self._results = None
     self._MeasureQuiescentPower(quiescent_measurement_time_s)
 
   def __del__(self):
     # TODO(jeremy): Remove once crbug.com/350841 is fixed.
     # Don't leave power monitoring processes running on the system.
     self._StopInternal()
     parent = super(PowerMetric, self)
     if hasattr(parent, '__del__'):
       parent.__del__()
 
   def _StopInternal(self):
     """Stop monitoring power if measurement is running. This function is
     idempotent."""
     if not self._running:
       return
     self._running = False
-    self._results = self._browser.platform.StopMonitoringPower()
+    self._results = self._platform.StopMonitoringPower()
     if self._results: # StopMonitoringPower() can return None.
       self._results['cpu_stats'] = (
           _SubtractCpuStats(self._browser.cpu_stats, self._starting_cpu_stats))
 
   def _MeasureQuiescentPower(self, measurement_time_s):
     """Measure quiescent power draw for the system."""
-    platform = self._browser.platform
-    if not platform.CanMonitorPower() or \
-        platform.CanMeasurePerApplicationPower() or \
+    if not self._platform.CanMonitorPower() or \
+        self._platform.CanMeasurePerApplicationPower() or \
         not measurement_time_s:
       return
 
     # Only perform quiescent measurement once per run.
     if PowerMetric._quiescent_power_draw_mwh:
       return
 
-    platform.StartMonitoringPower(self._browser)
+    self._platform.StartMonitoringPower(self._browser)
     time.sleep(measurement_time_s)
-    power_results = platform.StopMonitoringPower()
+    power_results = self._platform.StopMonitoringPower()
     PowerMetric._quiescent_power_draw_mwh = (
         power_results.get('energy_consumption_mwh', 0))
 
   def Start(self, _, tab):
-    if not tab.browser.platform.CanMonitorPower():
+    self._browser = tab.browser
+
+    if not self._platform.CanMonitorPower():
       return
 
     self._results = None
     self._StopInternal()
 
     # This line invokes top a few times, call before starting power measurement.
     self._starting_cpu_stats = self._browser.cpu_stats
-    self._browser.platform.StartMonitoringPower(self._browser)
+    self._platform.StartMonitoringPower(self._browser)
     self._running = True
 
   def Stop(self, _, tab):
-    if not tab.browser.platform.CanMonitorPower():
+    if not self._platform.CanMonitorPower():
       return
 
     self._StopInternal()
 
   def AddResults(self, _, results):
     """Add the collected power data into the results object.
 
     This function needs to be robust in the face of differing power data on
     various platforms. Therefore data existence needs to be checked when
     building up the results. Additionally 0 is a valid value for many of the
@@ skipping 86 matching lines @@
     if (('IdleWakeupCount' not in cpu_stats[process_type]) or
         ('IdleWakeupCount' not in start_cpu_stats[process_type])):
       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()
   return cpu_delta