Rename WebPageReplayPageCyclerTest to PageCyclerNetSimTest

chrome/test/functional/perf.py

 #!/usr/bin/env python
 # 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.
 
 """Basic pyauto performance tests.
 
 For tests that need to be run for multiple iterations (e.g., so that average
 and standard deviation values can be reported), the default number of iterations
 run for each of these tests is specified by |_DEFAULT_NUM_ITERATIONS|.
@@ skipping 2038 matching lines @@
   def testIntl2File(self):
     self.RunPageCyclerTest('intl2', 'Intl2File')
 
   def testMozFile(self):
     self.RunPageCyclerTest('moz', 'MozFile')
 
   def testMoz2File(self):
     self.RunPageCyclerTest('moz2', 'Moz2File')
 
 
-class WebPageReplayPageCyclerTest(BasePageCyclerTest):
-  """Tests to run Web Page Replay backed page cycler tests.
+class PageCyclerNetSimTest(BasePageCyclerTest):
+  """Run page cycler tests with network simulation via Web Page Replay.
 
   Web Page Replay is a proxy that can record and "replay" web pages with
   simulated network characteristics -- without having to edit the pages
   by hand. With WPR, tests can use "real" web content, and catch
   performance issues that may result from introducing network delays and
   bandwidth throttling.
 
   Setting 'PC_NO_AUTO=1' in the environment avoids automatically running
   through all the pages.
   Setting 'PC_RECORD=1' puts WPR in record mode.
   """
   _PATHS = {
       'archives':   'src/data/page_cycler/webpagereplay',
       'wpr':        'src/data/page_cycler/webpagereplay/{test_name}.wpr',
       'wpr_pub':    'src/tools/page_cycler/webpagereplay/tests/{test_name}.wpr',
       'start_page': 'src/tools/page_cycler/webpagereplay/start.html',
       'extension':  'src/tools/page_cycler/webpagereplay/extension',
       'replay':     'src/third_party/webpagereplay',
       'logs':       'src/webpagereplay_logs',
       }
 
   _BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                            '..', '..', '..', '..'))
   _IS_DNS_FORWARDED = False
   MAX_ITERATION_SECONDS = 180
 
   def setUp(self):
     """Performs necessary setup work before running each test."""
-    super(WebPageReplayPageCyclerTest, self).setUp()
+    super(PageCyclerNetSimTest, self).setUp()
     self.replay_dir = os.environ.get('PC_REPLAY_DIR')
     self.is_record_mode = 'PC_RECORD' in os.environ
     if self.is_record_mode:
       self._num_iterations = 1
 
   @classmethod
   def _Path(cls, key, **kwargs):
     """Provide paths for page cycler tests with Web Page Replay."""
     chromium_path = cls._PATHS[key].format(**kwargs)
     return os.path.join(cls._BASE_DIR, *chromium_path.split('/'))
 
   @classmethod
   def _ArchivePath(cls, test_name):
     has_private_archives = os.path.exists(cls._Path('archives'))
     key = 'wpr' if  has_private_archives else 'wpr_pub'
     return cls._Path(key, test_name=test_name)
 
   def ExtraChromeFlags(self):
     """Ensures Chrome is launched with custom flags.
 
     Returns:
       A list of extra flags to pass to Chrome when it is launched.
     """
-    flags = super(WebPageReplayPageCyclerTest, self).ExtraChromeFlags()
+    flags = super(PageCyclerNetSimTest, self).ExtraChromeFlags()
     flags.append('--load-extension=%s' % self._Path('extension'))
     if not self._IS_DNS_FORWARDED:
       flags.append('--host-resolver-rules=MAP * %s' % webpagereplay.REPLAY_HOST)
     flags.extend([
         '--testing-fixed-http-port=%s' % webpagereplay.HTTP_PORT,
         '--testing-fixed-https-port=%s' % webpagereplay.HTTPS_PORT,
         '--log-level=0',
         ])
     extra_flags = [
         '--disable-background-networking',
@@ skipping 31 matching lines @@
       replay_options.append('--record')
     if self.replay_dir:
       replay_dir = self.replay_dir
     else:
       self._Path('replay'),
     with webpagereplay.ReplayServer(
         replay_dir,
         self._ArchivePath(test_name),
         self._Path('logs'),
         replay_options):
-      super_self = super(WebPageReplayPageCyclerTest, self)
+      super_self = super(PageCyclerNetSimTest, self)
       super_self.RunPageCyclerTest(test_name, description)
 
   def test2012Q2(self):
     self.RunPageCyclerTest('2012Q2', '2012Q2')
 
 
 class MemoryTest(BasePerfTest):
   """Tests to measure memory consumption under different usage scenarios."""
 
   def ExtraChromeFlags(self):
@@ skipping 326 matching lines @@
     """Identifies the port number to which the server is currently bound.
 
     Returns:
       The numeric port number to which the server is currently bound.
     """
     return self._server.server_address[1]
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()