telemetry: Remove command line args from page test

tools/telemetry/telemetry/page/record_wpr_unittest.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 os
 import sys
 
 from telemetry import benchmark
 from telemetry import decorators
 from telemetry.core import util
@@ skipping 31 matching lines @@
     super(MockPageSet, self).__init__(archive_data_file='data/test.json')
     self.AddPage(MockPage(self, url))
 
 
 class MockPageTest(page_test.PageTest):
   def __init__(self):
     super(MockPageTest, self).__init__()
     self._action_name_to_run = "RunBaz"
     self.func_calls = []
 
-  @classmethod
-  def AddCommandLineArgs(cls, parser):
-    parser.add_option('--mock-page-test-option', action="store_true")
-
   def WillNavigateToPage(self, page, tab):
     self.func_calls.append('WillNavigateToPage')
 
   def DidNavigateToPage(self, page, tab):
     self.func_calls.append('DidNavigateToPage')
 
   def WillRunActions(self, page, tab):
     self.func_calls.append('WillRunActions')
 
   def DidRunActions(self, page, tab):
     self.func_calls.append('DidRunActions')
 
   def ValidatePage(self, page, tab, results):
     self.func_calls.append('ValidatePage')
 
   def WillStartBrowser(self, platform):
     self.func_calls.append('WillStartBrowser')
 
   def DidStartBrowser(self, browser):
     self.func_calls.append('DidStartBrowser')
 
 class MockBenchmark(benchmark.Benchmark):
   test = MockPageTest
   mock_page_set = None
 
   @classmethod
-  def AddTestCommandLineArgs(cls, group):
+  def AddBenchmarkCommandLineArgs(cls, group):
     group.add_option('', '--mock-benchmark-url', action='store', type='string')
 
   def CreatePageSet(self, options):
     kwargs = {}
     if options.mock_benchmark_url:
       kwargs['url'] = options.mock_benchmark_url
     self.mock_page_set = MockPageSet(**kwargs)
     return self.mock_page_set
 
 
@@ skipping 82 matching lines @@
         'non-existent-dummy-dir', mock_benchmark, flags)
     results = wpr_recorder.CreateResults()
     wpr_recorder.Record(results)
     self.assertEqual(set(mock_benchmark.mock_page_set.pages),
                      results.pages_that_succeeded)
 
   def testCommandLineFlags(self):
     flags = [
         '--page-repeat', '2',
         '--mock-benchmark-url', self._url,
-        '--mock-page-test-option',
     ]
     wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
                                           flags)
     # page_runner command-line args
     self.assertEquals(2, wpr_recorder.options.page_repeat)
     # benchmark command-line args
     self.assertEquals(self._url, wpr_recorder.options.mock_benchmark_url)
-    # benchmark's page_test command-line args
-    self.assertTrue(wpr_recorder.options.mock_page_test_option)
     # invalid command-line args
     self.assertFalse(hasattr(wpr_recorder.options, 'not_a_real_option'))
 
   def testRecordingEnabled(self):
     flags = ['--mock-benchmark-url', self._url]
     wpr_recorder = record_wpr.WprRecorder(self._test_data_dir, MockBenchmark(),
                                           flags)
     self.assertEqual(wpr_modes.WPR_RECORD,
                      wpr_recorder.options.browser_options.wpr_mode)
 
   def testFindAllActionNames(self):
     # The src/tools/telemetry/unittest_data/page_tests/ has been
     # populated with three simple Page Measurement classes, the first two of
     # which have action_name_to_run defined.
     action_names_to_run = record_wpr.FindAllActionNames(self._test_data_dir)
     self.assertTrue('RunFoo' in action_names_to_run)
     self.assertTrue('RunBar' in action_names_to_run)
     self.assertFalse('RunBaz' in action_names_to_run)
 
   # When the RecorderPageTest WillStartBrowser/DidStartBrowser function is
   # called, it forwards the call to the PageTest
   def testRecorderPageTest_BrowserMethods(self):
     record_page_test = record_wpr.RecorderPageTest([])
     record_page_test.page_test = MockBenchmark().test()
     record_page_test.WillStartBrowser(self._tab.browser.platform)
     record_page_test.DidStartBrowser(self._tab.browser)
     self.assertTrue('WillStartBrowser' in record_page_test.page_test.func_calls)
     self.assertTrue('DidStartBrowser' in record_page_test.page_test.func_calls)