Move the setting of test options to WillRunTest

tools/telemetry/telemetry/page/page_test.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
 
 from telemetry.page import test_expectations
 from telemetry.page.actions import all_page_actions
 from telemetry.page.actions import interact
 from telemetry.page.actions import navigate
 from telemetry.page.actions import page_action
@@ skipping 177 matching lines @@
     pass
 
   def DidStartBrowser(self, browser):
     """Override to customize the browser right after it has launched."""
     pass
 
   def CanRunForPage(self, page):  # pylint: disable=W0613
     """Override to customize if the test can be ran for the given page."""
     return True
 
-  def WillRunTest(self):
+  def WillRunTest(self, options):
     """Override to do operations before the page set(s) are navigated."""
-    pass
+    self.options = options
 
-  def DidRunTest(self, browser, results):
+  def DidRunTest(self, browser, results): # pylint: disable=W0613
     """Override to do operations after all page set(s) are completed.
 
     This will occur before the browser is torn down.
     """
-    pass
+    self.options = None
 
   def WillRunPageRepeats(self, page):
     """Override to do operations before each page is iterated over."""
     pass
 
   def DidRunPageRepeats(self, page):
     """Override to do operations after each page is iterated over."""
     pass
 
   def DidStartHTTPServer(self, tab):
@@ skipping 42 matching lines @@
   def TabForPage(self, page, browser):   # pylint: disable=W0613
     """Override to select a different tab for the page.  For instance, to
     create a new tab for every page, return browser.tabs.New()."""
     return browser.tabs[0]
 
   def ValidatePageSet(self, page_set):
     """Override to examine the page set before the test run.  Useful for
     example to validate that the pageset can be used with the test."""
     pass
 
-  def Run(self, options, page, tab, results):
-    self.options = options
-    interactive = options and options.interactive
+  def Run(self, page, tab, results):
+    interactive = self.options and self.options.interactive
     compound_action = GetCompoundActionFromPage(
         page, self._action_name_to_run, interactive)
     self.WillRunActions(page, tab)
     self._RunCompoundAction(page, tab, compound_action)
     self.DidRunActions(page, tab)
-    try:
-      self._test_method(page, tab, results)
-    finally:
-      self.options = None
+    self._test_method(page, tab, results)
 
   def _RunCompoundAction(self, page, tab, actions, run_setup_methods=True):
     for i, action in enumerate(actions):
       prev_action = actions[i - 1] if i > 0 else None
       next_action = actions[i + 1] if i < len(actions) - 1 else None
 
       if (action.RunsPreviousAction() and
           next_action and next_action.RunsPreviousAction()):
         raise page_action.PageActionFailed('Consecutive actions cannot both '
                                            'have RunsPreviousAction() == True.')
@@ skipping 28 matching lines @@
 
   def IsExiting(self):
     return self._exit_requested
 
   def RequestExit(self):
     self._exit_requested = True
 
   @property
   def action_name_to_run(self):
     return self._action_name_to_run