Telemetry: early exit from page runner

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 navigate
 from telemetry.page.actions import page_action
 
@@ skipping 41 matching lines @@
                test_method_name,
                action_name_to_run='',
                needs_browser_restart_after_each_run=False,
                discard_first_result=False,
                clear_cache_before_each_run=False):
     self.options = None
     try:
       self._test_method = getattr(self, test_method_name)
     except AttributeError:
       raise ValueError, 'No such method %s.%s' % (
-        self.__class_, test_method_name) # pylint: disable=E1101
+        self.__class_, test_method_name)  # pylint: disable=E1101
     self._action_name_to_run = action_name_to_run
     self._needs_browser_restart_after_each_run = (
         needs_browser_restart_after_each_run)
     self._discard_first_result = discard_first_result
     self._clear_cache_before_each_run = clear_cache_before_each_run
     self._close_tabs_before_run = True
     # If the test overrides the TabForPage method, it is considered a multi-tab
     # test.  The main difference between this and a single-tab test is that we
     # do not attempt recovery for the former if a tab or the browser crashes,
     # because we don't know the current state of tabs (how many are open, etc.)
     self.is_multi_tab_test = (self.__class__ is not PageTest and
                               self.TabForPage.__func__ is not
                               self.__class__.__bases__[0].TabForPage.__func__)
+    # _exit_requested is set to true when the test requests an early exit.
+    self._exit_requested = False
 
   @property
   def discard_first_result(self):
     """When set to True, the first run of the test is discarded.  This is
     useful for cases where it's desirable to have some test resource cached so
     the first run of the test can warm things up. """
     return self._discard_first_result
 
   @discard_first_result.setter
   def discard_first_result(self, discard):
     self._discard_first_result = discard
 
   @property
   def clear_cache_before_each_run(self):
     """When set to True, the browser's disk and memory cache will be cleared
     before each run."""
     return self._clear_cache_before_each_run
 
   @property
   def close_tabs_before_run(self):
     """When set to True, all tabs are closed before running the test for the
     first time."""
     return self._close_tabs_before_run
 
   @close_tabs_before_run.setter
   def close_tabs_before_run(self, close_tabs):
     self._close_tabs_before_run = close_tabs
 
-  def NeedsBrowserRestartAfterEachRun(self, tab): # pylint: disable=W0613
+  def NeedsBrowserRestartAfterEachRun(self, tab):  # pylint: disable=W0613
     """Override to specify browser restart after each run."""
     return self._needs_browser_restart_after_each_run
 
   def AddCommandLineOptions(self, parser):
     """Override to expose command-line options for this test.
 
     The provided parser is an optparse.OptionParser instance and accepts all
     normal results. The parsed options are available in Run as
     self.options."""
     pass
@@ skipping 10 matching lines @@
       action.CustomizeBrowserOptions(options)
 
   def WillStartBrowser(self, browser):
     """Override to manipulate the browser environment before it launches."""
     pass
 
   def DidStartBrowser(self, browser):
     """Override to customize the browser right after it has launched."""
     pass
 
-  def CanRunForPage(self, page): #pylint: disable=W0613
+  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, tab):
     """Override to do operations before the page set(s) are navigated."""
     pass
 
   def DidRunTest(self, tab, results):
     """Override to do operations after all page set(s) are completed.
 
@@ skipping 27 matching lines @@
     pass
 
   def WillRunAction(self, page, tab, action):
     """Override to do operations before running the action on the page."""
     pass
 
   def DidRunAction(self, page, tab, action):
     """Override to do operations after running the action on the page."""
     pass
 
-  def CreatePageSet(self, args, options):  # pylint: disable=W0613
+  def CreatePageSet(self, args, options):   # pylint: disable=W0613
     """Override to make this test generate its own page set instead of
     allowing arbitrary page sets entered from the command-line."""
     return None
 
-  def CreateExpectations(self, page_set):  # pylint: disable=W0613
+  def CreateExpectations(self, page_set):   # pylint: disable=W0613
     """Override to make this test generate its own expectations instead of
     any that may have been defined in the page set."""
     return test_expectations.TestExpectations()
 
-  def TabForPage(self, page, tab):  # pylint: disable=W0613
+  def TabForPage(self, page, tab):   # pylint: disable=W0613
     """Override to select a different tab for the page.  For instance, to
     create a new tab for every page, return tab.browser.tabs.New()."""
     return tab
 
   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):
@@ skipping 36 matching lines @@
     Runs the 'navigate_steps' page attribute as a compound action.
     """
     navigate_actions = GetCompoundActionFromPage(page, 'navigate_steps')
     if not any(isinstance(action, navigate.NavigateAction)
         for action in navigate_actions):
       raise page_action.PageActionFailed(
           'No NavigateAction in navigate_steps')
 
     self._RunCompoundAction(page, tab, navigate_actions, False)
 
+  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