Move user_story.shared_user_story_state to story.shared_state

tools/telemetry/telemetry/user_story/user_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 94 matching lines @@
     try:
       state.DidRunUserStory(results)
     except Exception:
       if not has_existing_exception:
         raise
       # Print current exception and propagate existing exception.
       exception_formatter.PrintFormattedException(
           msg='Exception from DidRunUserStory: ')
 
 class UserStoryGroup(object):
-  def __init__(self, shared_user_story_state_class):
-    self._shared_user_story_state_class = shared_user_story_state_class
+  def __init__(self, shared_state_class):
+    self._shared_state_class = shared_state_class
     self._user_stories = []
 
   @property
-  def shared_user_story_state_class(self):
-    return self._shared_user_story_state_class
+  def shared_state_class(self):
+    return self._shared_state_class
 
   @property
   def user_stories(self):
     return self._user_stories
 
   def AddUserStory(self, user_story):
-    assert (user_story.shared_user_story_state_class is
-            self._shared_user_story_state_class)
+    assert (user_story.shared_state_class is
+            self._shared_state_class)
     self._user_stories.append(user_story)
 
 
 def StoriesGroupedByStateClass(user_story_set, allow_multiple_groups):
   """ Returns a list of user story groups which each contains user stories with
-  the same shared_user_story_state_class.
+  the same shared_state_class.
 
   Example:
     Assume A1, A2, A3 are user stories with same shared user story class, and
     similar for B1, B2.
     If their orders in user story set is A1 A2 B1 B2 A3, then the grouping will
     be [A1 A2] [B1 B2] [A3].
 
   It's purposefully done this way to make sure that order of user
   stories are the same of that defined in user_story_set. It's recommended that
   user stories with the same states should be arranged next to each others in
   user story sets to reduce the overhead of setting up & tearing down the
   shared user story state.
   """
   user_story_groups = []
   user_story_groups.append(
-      UserStoryGroup(user_story_set[0].shared_user_story_state_class))
+      UserStoryGroup(user_story_set[0].shared_state_class))
   for user_story in user_story_set:
-    if (user_story.shared_user_story_state_class is not
-        user_story_groups[-1].shared_user_story_state_class):
+    if (user_story.shared_state_class is not
+        user_story_groups[-1].shared_state_class):
       if not allow_multiple_groups:
         raise ValueError('This UserStorySet is only allowed to have one '
-                         'SharedUserStoryState but contains the following '
-                         'SharedUserStoryState classes: %s, %s.\n Either '
-                         'remove the extra SharedUserStoryStates or override '
+                         'SharedState but contains the following '
+                         'SharedState classes: %s, %s.\n Either '
+                         'remove the extra SharedStates or override '
                          'allow_mixed_story_states.' % (
-                         user_story_groups[-1].shared_user_story_state_class,
-                         user_story.shared_user_story_state_class))
+                         user_story_groups[-1].shared_state_class,
+                         user_story.shared_state_class))
       user_story_groups.append(
-          UserStoryGroup(user_story.shared_user_story_state_class))
+          UserStoryGroup(user_story.shared_state_class))
     user_story_groups[-1].AddUserStory(user_story)
   return user_story_groups
 
 
 def Run(test, user_story_set, expectations, finder_options, results,
         max_failures=None):
   """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 user story runner
@@ skipping 26 matching lines @@
       user_stories,
       user_story_set.allow_mixed_story_states)
 
   for group in user_story_groups:
     state = None
     try:
       for _ in xrange(finder_options.pageset_repeat):
         for user_story in group.user_stories:
           for _ in xrange(finder_options.page_repeat):
             if not state:
-              state = group.shared_user_story_state_class(
+              state = group.shared_state_class(
                   test, finder_options, user_story_set)
             results.WillRunPage(user_story)
             try:
               _WaitForThermalThrottlingIfNeeded(state.platform)
               _RunUserStoryAndProcessErrorIfNeeded(
                   expectations, user_story, results, state)
             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.
@@ skipping 110 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.')