Telemetry: extends Platform abstraction.

tools/telemetry/telemetry/page_runner.py

 # Copyright (c) 2012 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 logging
 import os
 import time
 import traceback
 import urlparse
 import random
 
 from telemetry import browser_gone_exception
 from telemetry import page_test
 from telemetry import tab_crash_exception
 from telemetry import util
 from telemetry import wpr_modes
 
 class PageState(object):
   def __init__(self):
     self.did_login = False
 
 class _RunState(object):
   def __init__(self):
     self.first_browser = True
     self.browser = None
     self.tab = None
     self.trace_tab = None
+    self.performance_test = False
 
   def Close(self):
     if self.trace_tab:
       self.trace_tab.Disconnect()
       self.trace_tab = None
 
     if self.tab:
       self.tab.Disconnect()
       self.tab = None
 
     if self.browser:
+      if self.performance_test:
+        self.browser.platform.SetFullPerformanceModeEnabled(False)
       self.browser.Close()
       self.browser = None
 
+
 def _ShufflePageSet(page_set, options):
   if options.test_shuffle_order_file and not options.test_shuffle:
     raise Exception('--test-shuffle-order-file requires --test-shuffle.')
 
   if options.test_shuffle_order_file:
     return page_set.ReorderPageSet(options.test_shuffle_order_file)
 
   pages = page_set.pages[:]
   if options.test_shuffle:
     random.Random().shuffle(pages)
@@ skipping 77 matching lines @@
               self._RunPage(options, page, state.tab, test, results)
             except tab_crash_exception.TabCrashException:
               # Close the crashed tab. We'll open another before the next run.
               if state.browser.supports_tab_control:
                 state.tab.Close()
                 state.tab = None
               # If we don't support tab control, just restart the browser.
               else:
                 state.Close()
 
+            if (state.browser.platform.CanMonitorThermalThrottling() and
+                state.browser.platform.IsThermallyThrottled()):

[aberent, 2013/01/29 14:03:36]

See my other comments on thermal throttling. This is not an adequate test since
the device may have recovered before the test finishes (it doesn't take long to
recover once it slows the clock). You need to (indirectly) call
ThermalThrottle.HasBeenThrottled or similar.

[bulach, 2013/02/22 11:54:25]

good point, added a check for "IsThrottled" at the beginning of the test, and
then HasBeenThrottled to the end of it, please double check.

+              raise Exception('Device was thermally throttled during '
+                              'performance tests.')

[tonyg, 2013/02/21 18:07:08]

I'm on the fence about whether this should really raise an exception or just
print a warning. I guess the real question is how flaky this will make the bots.

Perhaps we should only do one thing at a time. First, in this patch, disable
frequency scaling and we can see how that affects noise on the bots. Then, in a
subsequent patch, change the thermal throttling warning to an exception and we
can monitor the bots closely to see if they become flaky.

[bulach, 2013/02/22 11:54:25]

agree. done as just messages for now.

+
             if options.trace_dir and state.trace_tab:
               self._EndTracing(state, options, page)
             break
           except browser_gone_exception.BrowserGoneException:
             logging.warning('Lost connection to browser. Retrying.')
             state.Close()
             tries -= 1
             if not tries:
               logging.error('Lost connection to browser 3 times. Failing.')
               raise
@@ skipping 64 matching lines @@
     def IsPageLoaded():
       return tab.runtime.Evaluate(expression)
 
     # Wait until the form is submitted and the page completes loading.
     util.WaitFor(IsPageLoaded, 60)
 
   def _SetupBrowser(self, state, test, possible_browser, credentials_path,
                     archive_path):
     assert not state.tab
     state.browser = possible_browser.Create()
+
+    if possible_browser.options.performance_test:
+      state.performance_test = True
+      state.browser.platform.SetFullPerformanceModeEnabled(True)

[tonyg, 2013/02/21 18:07:08]

I wonder if it would be more robust to call
SetFullPerformanceModeEnable(True/False) from within the Browser class itself
(in Create and Close).

[bulach, 2013/02/22 11:54:25]

Done.

+
     state.browser.credentials.credentials_path = credentials_path
     test.SetUpBrowser(state.browser)
 
     if state.first_browser:
       state.browser.credentials.WarnIfMissingCredentials(self.page_set)
       state.first_browser = False
 
     state.browser.SetReplayArchivePath(archive_path)
 
   def _SetupTracingTab(self, state):
@@ skipping 79 matching lines @@
     return True
 
   def _CleanUpPage(self, page, tab, page_state): # pylint: disable=R0201
     if page.credentials and page_state.did_login:
       tab.browser.credentials.LoginNoLongerNeeded(tab, page.credentials)
     try:
       tab.runtime.Evaluate("""window.chrome && chrome.benchmarking &&
                               chrome.benchmarking.closeConnections()""")
     except Exception:
       pass