Revert of telemetry: Remove command line args from page test

tools/perf/measurements/page_cycler_unittest.py

 # Copyright 2013 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 unittest
 
 from telemetry.core import browser_options
 from telemetry.page import page_runner
 from telemetry.results import page_test_results
 from telemetry.unittest_util import simple_mock
@@ skipping 76 matching lines @@
 
 class FakePlatform(object):
   def GetOSName(self):
     return 'fake'
   def CanMonitorPower(self):
     return False
 
 
 class PageCyclerUnitTest(unittest.TestCase):
 
-  def SetUpCycler(self, page_repeat=1, pageset_repeat=10, cold_load_percent=50,
-                  record_v8_object_stats=False, report_speed_index=False,
-                  setup_memory_module=False):
-    cycler = page_cycler.PageCycler(
-        page_repeat = page_repeat,
-        pageset_repeat = pageset_repeat,
-        cold_load_percent = cold_load_percent,
-        record_v8_object_stats = record_v8_object_stats,
-        report_speed_index = report_speed_index)
+  def SetUpCycler(self, args, setup_memory_module=False):
+    cycler = page_cycler.PageCycler()
     options = browser_options.BrowserFinderOptions()
     options.browser_options.platform = FakePlatform()
     parser = options.CreateParser()
     page_runner.AddCommandLineArgs(parser)
-    args = ['--page-repeat=%i' % page_repeat,
-            '--pageset-repeat=%i' % pageset_repeat]
+    cycler.AddCommandLineArgs(parser)
+    cycler.SetArgumentDefaults(parser)
     parser.parse_args(args)
     page_runner.ProcessCommandLineArgs(parser, options)
+    cycler.ProcessCommandLineArgs(parser, options)
     cycler.CustomizeBrowserOptions(options.browser_options)
 
     if setup_memory_module:
       # Mock out memory metrics; the real ones require a real browser.
       mock_memory_metric = MockMemoryMetric()
 
       mock_memory_module = simple_mock.MockObject()
       mock_memory_module.ExpectCall(
         'MemoryMetric').WithArgs(simple_mock.DONT_CARE).WillReturn(
         mock_memory_metric)
 
       real_memory_module = page_cycler.memory
       try:
         page_cycler.memory = mock_memory_module
         browser = FakeBrowser()
         cycler.WillStartBrowser(options.browser_options.platform)
         cycler.DidStartBrowser(browser)
       finally:
         page_cycler.memory = real_memory_module
 
     return cycler
 
   def testOptionsColdLoadNoArgs(self):
-    cycler = self.SetUpCycler()
+    cycler = self.SetUpCycler([])
 
     self.assertEquals(cycler._cold_run_start_index, 5)
 
   def testOptionsColdLoadPagesetRepeat(self):
-    cycler = self.SetUpCycler(pageset_repeat=20, page_repeat=2)
+    cycler = self.SetUpCycler(['--pageset-repeat=20', '--page-repeat=2'])
 
     self.assertEquals(cycler._cold_run_start_index, 20)
 
   def testOptionsColdLoadRequested(self):
-    cycler = self.SetUpCycler(pageset_repeat=21, page_repeat=2,
-                              cold_load_percent=40)
+    cycler = self.SetUpCycler(['--pageset-repeat=21', '--page-repeat=2',
+                               '--cold-load-percent=40'])
 
     self.assertEquals(cycler._cold_run_start_index, 26)
 
   def testCacheHandled(self):
-    cycler = self.SetUpCycler(pageset_repeat=5,
-                              cold_load_percent=50,
-                              setup_memory_module=True)
+    cycler = self.SetUpCycler(['--pageset-repeat=5',
+                               '--cold-load-percent=50'],
+                              True)
 
     url_name = 'http://fakepage.com'
     page = FakePage(url_name)
     tab = FakeTab()
 
     for i in range(5):
       results = page_test_results.PageTestResults()
       results.WillRunPage(page)
       cycler.WillNavigateToPage(page, tab)
       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
                        'Iteration %d tab.clear_cache_calls %d' %
                        (i, tab.clear_cache_calls))
       cycler.ValidateAndMeasurePage(page, tab, results)
       results.DidRunPage(page)
 
       values = results.all_page_specific_values
       self.assertGreater(len(values), 2)
 
       self.assertEqual(values[0].page, page)
       chart_name = 'cold_times' if i == 0 or i > 2 else 'warm_times'
       self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
       self.assertEqual(values[0].units, 'ms')
 
       cycler.DidNavigateToPage(page, tab)
 
   def testColdWarm(self):
-    cycler = self.SetUpCycler(pageset_repeat=3, setup_memory_module=True)
+    cycler = self.SetUpCycler(['--pageset-repeat=3'], True)
     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
     tab = FakeTab()
     for i in range(3):
       for page in pages:
         results = page_test_results.PageTestResults()
         results.WillRunPage(page)
         cycler.WillNavigateToPage(page, tab)
         cycler.ValidateAndMeasurePage(page, tab, results)
         results.DidRunPage(page)
 
         values = results.all_page_specific_values
         self.assertGreater(len(values), 2)
 
         self.assertEqual(values[0].page, page)
 
         chart_name = 'cold_times' if i == 0 or i > 1 else 'warm_times'
         self.assertEqual(values[0].name, '%s.page_load_time' % chart_name)
         self.assertEqual(values[0].units, 'ms')
 
         cycler.DidNavigateToPage(page, tab)
 
   def testResults(self):
-    cycler = self.SetUpCycler(setup_memory_module=True)
+    cycler = self.SetUpCycler([], True)
 
     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
     tab = FakeTab()
 
     for i in range(2):
       for page in pages:
         results = page_test_results.PageTestResults()
         results.WillRunPage(page)
         cycler.WillNavigateToPage(page, tab)
         cycler.ValidateAndMeasurePage(page, tab, results)
@@ skipping 11 matching lines @@
           self.assertEqual(value.page, page)
           self.assertEqual(value.name,
                            'cpu_utilization.cpu_utilization_%s' % expected)
           self.assertEqual(value.units, '%')
 
         cycler.DidNavigateToPage(page, tab)
 
   def testLegacyPagesAvoidCrossRenderNavigation(self):
     # For legacy page cyclers with file URLs, verify that WillNavigateToPage
     # does an initial navigate to avoid paying for a cross-renderer navigation.
-    cycler = self.SetUpCycler(setup_memory_module=True)
+    cycler = self.SetUpCycler([], True)
     pages = [FakePage('file://fakepage1.com'), FakePage('file://fakepage2.com')]
     tab = FakeTab()
 
     self.assertEqual([], tab.navigated_urls)
     for page in pages * 2:
       cycler.WillNavigateToPage(page, tab)
       self.assertEqual(
           ['http://fakeserver:99999/nonexistent.html'], tab.navigated_urls)