[Telemetry] Introduce RunState.SetUpBeforeRunPage and RunState.TearDownAfterRunPage.

tools/telemetry/telemetry/page/page_runner.py

Index: tools/telemetry/telemetry/page/page_runner.py
diff --git a/tools/telemetry/telemetry/page/page_runner.py b/tools/telemetry/telemetry/page/page_runner.py
index e06261e5e6590dceac75ac559663500065c25ff2..5064c64ece4719b7213bbd29f41b3571ce4a190f 100644
--- a/tools/telemetry/telemetry/page/page_runner.py
+++ b/tools/telemetry/telemetry/page/page_runner.py
@@ -1,4 +1,4 @@
-# Copyright 2014 The Chromium Authors. All rights reserved.
+#  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.
 
@@ -27,8 +27,10 @@ from telemetry.value import skip
 
 
 class _RunState(object):
-  def __init__(self, test):
+  def __init__(self, test, finder_options):
     self.browser = None
+    self._finder_options = finder_options
+    self._possible_browser = self._GetPossibleBrowser(test, finder_options)
 
     # TODO(slamm): Remove _append_to_existing_wpr when replay lifetime changes.
     self._append_to_existing_wpr = False
@@ -38,10 +40,49 @@ class _RunState(object):
     self._current_page = None
     self._current_tab = None
 
-  def _PrepareWpr(self, finder_options, network_controller, archive_path,
+  def _GetPossibleBrowser(self, test, finder_options):
+    ''' Return a possible_browser with the given options. '''
+    possible_browser = browser_finder.FindBrowser(finder_options)
+    if not possible_browser:
+      raise browser_finder.BrowserFinderException(
+          'No browser found.\n\nAvailable browsers:\n%s\n' %
+          '\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)))
+    finder_options.browser_options.browser_type = (
+        possible_browser.browser_type)
+
+    if (not decorators.IsEnabled(test, possible_browser) and
+        not finder_options.run_disabled_tests):
+      logging.warning('You are trying to run a disabled test.')
+      logging.warning('Pass --also-run-disabled-tests to squelch this message.')
+      sys.exit(0)
+
+    if possible_browser.IsRemote():
+      possible_browser.RunRemote()
+      sys.exit(0)
+    return possible_browser
+
+  def WillRunPage(self, page):
+    if self._finder_options.profiler:
+      self._StartProfiling(self._current_page)
+    self._current_page = page
+
+  def DidRunPage(self):
+    if self._finder_options.profiler:
+      self._StopProfiling()
+
+    if self._test.StopBrowserAfterPage(self.browser, self._current_page):
+      self.StopBrowser()
+    self._current_page = None
+    self._current_tab = None
+
+  @property
+  def platform(self):
+    return self._possible_browser.platform
+
+  def _PrepareWpr(self, network_controller, archive_path,
                   make_javascript_deterministic):
-    browser_options = finder_options.browser_options
-    if finder_options.use_live_sites:
+    browser_options = self._finder_options.browser_options
+    if self._finder_options.use_live_sites:
       browser_options.wpr_mode = wpr_modes.WPR_OFF
     elif browser_options.wpr_mode != wpr_modes.WPR_RECORD:
       browser_options.wpr_mode = (
@@ -60,30 +101,28 @@ class _RunState(object):
         archive_path, wpr_mode, browser_options.netsim,
         browser_options.extra_wpr_args, make_javascript_deterministic)
 
-  def StartBrowserIfNeeded(self, test, page_set, page, possible_browser,
-                          finder_options):
+  def StartBrowserIfNeeded(self, test, page_set, page):
     started_browser = not self.browser
-    self._PrepareWpr(
-        finder_options, possible_browser.platform.network_controller,
-        page.archive_path, page_set.make_javascript_deterministic)
+    self._PrepareWpr(self.platform.network_controller, page.archive_path,
+                     page_set.make_javascript_deterministic)
     if self.browser:
       # Set new credential path for browser.
       self.browser.credentials.credentials_path = page.credentials_path
-      self.browser.platform.network_controller.UpdateReplayForExistingBrowser()
+      self.platform.network_controller.UpdateReplayForExistingBrowser()
     else:
-      test.CustomizeBrowserOptionsForSinglePage(page, finder_options)
-      possible_browser.SetCredentialsPath(page.credentials_path)
+      test.CustomizeBrowserOptionsForSinglePage(page, self._finder_options)
+      self._possible_browser.SetCredentialsPath(page.credentials_path)
 
-      test.WillStartBrowser(possible_browser.platform)
-      self.browser = possible_browser.Create(finder_options)
+      test.WillStartBrowser(self.platform)
+      self.browser = self._possible_browser.Create(self._finder_options)
       test.DidStartBrowser(self.browser)
 
       if self._first_browser:
         self._first_browser = False
         self.browser.credentials.WarnIfMissingCredentials(page)
         logging.info('OS: %s %s',
-                     self.browser.platform.GetOSName(),
-                     self.browser.platform.GetOSVersionName())
+                     self.platform.GetOSName(),
+                     self.platform.GetOSVersionName())
         if self.browser.supports_system_info:
           system_info = self.browser.GetSystemInfo()
           if system_info.model_name:
@@ -129,9 +168,8 @@ class _RunState(object):
       if started_browser:
         self.browser.tabs[0].WaitForDocumentReadyStateToBeComplete()
 
-  def PreparePage(self, page):
-    self._current_page = page
-    self._current_tab = self._test.TabForPage(page, self.browser)
+  def PreparePage(self):
+    self._current_tab = self._test.TabForPage(self._current_page, self.browser)
     if self._current_page.is_file:
       self.browser.SetHTTPServerDirectories(
           self._current_page.page_set.serving_dirs |
@@ -164,8 +202,6 @@ class _RunState(object):
     if self._current_page.credentials and self._did_login_for_current_page:
       self.browser.credentials.LoginNoLongerNeeded(
           self._current_tab, self._current_page.credentials)
-    self._current_page = None
-    self._current_tab = None
 
   def StopBrowser(self):
     if self.browser:
@@ -177,18 +213,19 @@ class _RunState(object):
       # not overwrite it.
       self._append_to_existing_wpr = True
 
-  def StartProfiling(self, page, finder_options):
-    output_file = os.path.join(finder_options.output_dir, page.file_safe_name)
-    is_repeating = (finder_options.page_repeat != 1 or
-                    finder_options.pageset_repeat != 1)
+  def _StartProfiling(self, page):
+    output_file = os.path.join(self._finder_options.output_dir,
+                               page.file_safe_name)
+    is_repeating = (self._finder_options.page_repeat != 1 or
+                    self._finder_options.pageset_repeat != 1)
     if is_repeating:
       output_file = util.GetSequentialFileName(output_file)
-    self.browser.platform.profiling_controller.Start(
-        finder_options.profiler, output_file)
+    self.platform.profiling_controller.Start(
+        self._finder_options.profiler, output_file)
 
-  def StopProfiling(self):
+  def _StopProfiling(self):
     if self.browser:
-      self.browser.platform.profiling_controller.Stop()
+      self.platform.profiling_controller.Stop()
 
 
 def AddCommandLineArgs(parser):
@@ -242,8 +279,8 @@ def ProcessCommandLineArgs(parser, args):
     parser.error('--pageset-repeat must be a positive integer.')
 
 
-def _RunPageAndRetryRunIfNeeded(test, page_set, expectations, finder_options,
-                        page, possible_browser, results, state):
+def _RunPageAndRetryRunIfNeeded(test, page_set, expectations,
+                                page, results, state):
   max_attempts = test.attempts
   attempt_num = 0
   while attempt_num < max_attempts:
@@ -255,8 +292,7 @@ def _RunPageAndRetryRunIfNeeded(test, page_set, expectations, finder_options,
         state.StopBrowser()
         # If we are restarting the browser for each page customize the per page
         # options for just the current page before starting the browser.
-      state.StartBrowserIfNeeded(
-          test, page_set, page, possible_browser, finder_options)
+      state.StartBrowserIfNeeded(test, page_set, page)
       if not page.CanRunOnBrowser(browser_info.BrowserInfo(state.browser)):
         logging.info('Skip test for page %s because browser is not supported.'
                      % page.url)
@@ -264,14 +300,13 @@ def _RunPageAndRetryRunIfNeeded(test, page_set, expectations, finder_options,
 
       expectation = expectations.GetExpectationForPage(state.browser, page)
 
-      _WaitForThermalThrottlingIfNeeded(state.browser.platform)
+      _WaitForThermalThrottlingIfNeeded(state.platform)
 
-      if finder_options.profiler:
-        state.StartProfiling(page, finder_options)
+      state.WillRunPage(page)
 
       try:
         _RunPageAndProcessErrorIfNeeded(page, state, expectation, results)
-        _CheckThermalThrottling(state.browser.platform)
+        _CheckThermalThrottling(state.platform)
       except exceptions.TabCrashException as e:
         if test.is_multi_tab_test:
           logging.error('Aborting multi-tab test after tab %s crashed',
@@ -279,13 +314,7 @@ def _RunPageAndRetryRunIfNeeded(test, page_set, expectations, finder_options,
           raise
         logging.warning(str(e))
         state.StopBrowser()
-
-      if finder_options.profiler:
-        state.StopProfiling()
-
-      if (test.StopBrowserAfterPage(state.browser, page)):
-        state.StopBrowser()
-
+      state.DidRunPage()
       return
     except exceptions.BrowserGoneException as e:
       state.StopBrowser()
@@ -325,32 +354,9 @@ def Run(test, page_set, expectations, finder_options, results):
   """Runs a given test against a given page_set with the given options."""
   test.ValidatePageSet(page_set)
 
-  # Create a possible_browser with the given options.
-  try:
-    possible_browser = browser_finder.FindBrowser(finder_options)
-  except browser_finder.BrowserTypeRequiredException, e:
-    sys.stderr.write(str(e) + '\n')
-    sys.exit(-1)
-  if not possible_browser:
-    sys.stderr.write(
-        'No browser found. Available browsers:\n%s\n' %
-        '\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)))
-    sys.exit(-1)
-
   browser_options = finder_options.browser_options
-  browser_options.browser_type = possible_browser.browser_type
   test.CustomizeBrowserOptions(browser_options)
 
-  if (not decorators.IsEnabled(test, possible_browser) and
-      not finder_options.run_disabled_tests):
-    logging.warning('You are trying to run a disabled test.')
-    logging.warning('Pass --also-run-disabled-tests to squelch this message.')
-    return
-
-  if possible_browser.IsRemote():
-    possible_browser.RunRemote()
-    sys.exit(0)
-
   # Reorder page set based on options.
   pages = _ShuffleAndFilterPageSet(page_set, finder_options)
 
@@ -378,7 +384,7 @@ def Run(test, page_set, expectations, finder_options, results):
   if not pages:
     return
 
-  state = _RunState(test)
+  state = _RunState(test, finder_options)
   pages_with_discarded_first_result = set()
   max_failures = finder_options.max_failures  # command-line gets priority
   if max_failures is None:
@@ -394,8 +400,7 @@ def Run(test, page_set, expectations, finder_options, results):
           results.WillRunPage(page)
           try:
             _RunPageAndRetryRunIfNeeded(
-                test, page_set, expectations, finder_options, page,
-                possible_browser, results, state)
+                test, page_set, expectations, page, results, state)
           finally:
             discard_run = (test.discard_first_result and
                            page not in pages_with_discarded_first_result)
@@ -482,7 +487,7 @@ def _RunPageAndProcessErrorIfNeeded(page, state, expectation, results):
     exception_formatter.PrintFormattedException(msg=msg)
 
   try:
-    state.PreparePage(page)
+    state.PreparePage()
     state.ImplicitPageNavigation()
     state.RunPage(results)
   except page_test.TestNotSupportedOnPlatformFailure: