[Telemetry] Re-add API to tear down state after each story run

telemetry/telemetry/internal/story_runner.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 logging
 import optparse
 import os
 import sys
 import time
 
@@ skipping 153 matching lines @@
                          'remove the extra SharedStates or override '
                          'allow_mixed_story_states.' % (
                          story_groups[-1].shared_state_class,
                          story.shared_state_class))
       story_groups.append(
           StoryGroup(story.shared_state_class))
     story_groups[-1].AddStory(story)
   return story_groups
 
 
-def Run(test, story_set, finder_options, results, max_failures=None):
+def Run(test, story_set, finder_options, results, max_failures=None,
+        should_tear_down_state_after_each_story_run=False):
   """Runs a given test against a given page_set with the given options.
 
   Stop execution for unexpected exceptions such as KeyboardInterrupt.
   We "white list" certain exceptions for which the story runner
   can continue running the remaining stories.
   """
   # Filter page set based on options.
   stories = filter(story_module.StoryFilter.IsSelected, story_set)
 
   if (not finder_options.use_live_sites and story_set.bucket and
@@ skipping 19 matching lines @@
       stories,
       story_set.allow_mixed_story_states)
 
   for group in story_groups:
     state = None
     try:
       for _ in xrange(finder_options.pageset_repeat):
         for story in group.stories:
           for _ in xrange(finder_options.page_repeat):
             if not state:
+              # Construct shared state by using a copy of finder_options. Shared
+              # state may update the finder_options. If we tear down the shared
+              # state after this story run, we want to construct the shared
+              # state for the next story from the original finder_options.
               state = group.shared_state_class(
-                  test, finder_options, story_set)
+                  test, finder_options.Copy(), story_set)
             results.WillRunPage(story)
             try:
               _WaitForThermalThrottlingIfNeeded(state.platform)
               _RunStoryAndProcessErrorIfNeeded(story, results, state, test)
             except exceptions.Error:
               # Catch all Telemetry errors to give the story a chance to retry.
               # The retry is enabled by tearing down the state and creating
               # a new state instance in the next iteration.
               try:
                 # If TearDownState raises, do not catch the exception.
                 # (The Error was saved as a failure value.)
                 state.TearDownState()
               finally:
                 # Later finally-blocks use state, so ensure it is cleared.
                 state = None
             finally:
               has_existing_exception = sys.exc_info() != (None, None, None)
               try:
                 if state:
                   _CheckThermalThrottling(state.platform)
                 results.DidRunPage(story)
               except Exception:
                 if not has_existing_exception:
                   raise
                 # Print current exception and propagate existing exception.
                 exception_formatter.PrintFormattedException(
                     msg='Exception from result processing:')
+              if state and should_tear_down_state_after_each_story_run:
+                state.TearDownState()
+                state = None
           if (effective_max_failures is not None and
               len(results.failures) > effective_max_failures):
             logging.error('Too many failures. Aborting.')
             return
     finally:
       if state:
         has_existing_exception = sys.exc_info() != (None, None, None)
         try:
           state.TearDownState()
         except Exception:
@@ skipping 39 matching lines @@
     if any(not isinstance(p, page.Page) for p in stories.stories):
       raise Exception(
           'PageTest must be used with StorySet containing only '
           'telemetry.page.Page stories.')
 
   benchmark_metadata = benchmark.GetMetadata()
   with results_options.CreateResults(
       benchmark_metadata, finder_options,
       benchmark.ValueCanBeAddedPredicate) as results:
     try:
-      Run(pt, stories, finder_options, results, benchmark.max_failures)
+      Run(pt, stories, finder_options, results, benchmark.max_failures,
+          benchmark.ShouldTearDownStateAfterEachStoryRun())
       return_code = min(254, len(results.failures))
     except Exception:
       exception_formatter.PrintFormattedException()
       return_code = 255
 
     try:
       bucket = cloud_storage.BUCKET_ALIASES[finder_options.upload_bucket]
       if finder_options.upload_results:
         results.UploadTraceFilesToCloud(bucket)
         results.UploadProfilingFilesToCloud(bucket)
@@ skipping 79 matching lines @@
     logging.warning('Device is thermally throttled before running '
                     'performance tests, results will vary.')
 
 
 def _CheckThermalThrottling(platform):
   if not platform.CanMonitorThermalThrottling():
     return
   if platform.HasBeenThermallyThrottled():
     logging.warning('Device has been thermally throttled during '
                     'performance tests, results will vary.')