Revert of telemetry: Remove command line args from page test

tools/perf/measurements/page_cycler.py

 # Copyright 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.
 
 """The page cycler measurement.
 
 This measurement registers a window load handler in which is forces a layout and
 then records the value of performance.now(). This call to now() measures the
 time from navigationStart (immediately after the previous page's beforeunload
 event) until after the layout in the page's load event. In addition, two garbage
@@ skipping 12 matching lines @@
 from metrics import memory
 from metrics import power
 from metrics import speedindex
 from metrics import v8_object_stats
 from telemetry.core import util
 from telemetry.page import page_test
 from telemetry.value import scalar
 
 
 class PageCycler(page_test.PageTest):
-  def __init__(self, page_repeat, pageset_repeat, cold_load_percent=50,
-               record_v8_object_stats=False, report_speed_index=False):
-    super(PageCycler, self).__init__()
+  options = {'pageset_repeat': 10}
+
+  def __init__(self, *args, **kwargs):
+    super(PageCycler, self).__init__(*args, **kwargs)
 
     with open(os.path.join(os.path.dirname(__file__),
                            'page_cycler.js'), 'r') as f:
       self._page_cycler_js = f.read()
 
-    self._record_v8_object_stats = record_v8_object_stats
-    self._report_speed_index = report_speed_index
     self._speedindex_metric = speedindex.SpeedIndexMetric()
     self._memory_metric = None
     self._power_metric = None
     self._cpu_metric = None
     self._v8_object_stats_metric = None
     self._has_loaded_page = collections.defaultdict(int)
     self._initial_renderer_url = None  # to avoid cross-renderer navigation
 
-    cold_runs_percent_set = (cold_load_percent != None)
+  @classmethod
+  def AddCommandLineArgs(cls, parser):
+    parser.add_option('--v8-object-stats',
+        action='store_true',
+        help='Enable detailed V8 object statistics.')
+
+    parser.add_option('--report-speed-index',
+        action='store_true',
+        help='Enable the speed index metric.')
+
+    parser.add_option('--cold-load-percent', type='int', default=50,
+                      help='%d of page visits for which a cold load is forced')
+
+  @classmethod
+  def ProcessCommandLineArgs(cls, parser, args):
+    cls._record_v8_object_stats = args.v8_object_stats
+    cls._report_speed_index = args.report_speed_index
+
+    cold_runs_percent_set = (args.cold_load_percent != None)
     # Handle requests for cold cache runs
     if (cold_runs_percent_set and
-        (cold_load_percent < 0 or cold_load_percent > 100)):
-      raise Exception('cold-load-percent must be in the range [0-100]')
+        (args.cold_load_percent < 0 or args.cold_load_percent > 100)):
+      raise Exception('--cold-load-percent must be in the range [0-100]')
 
     # Make sure _cold_run_start_index is an integer multiple of page_repeat.
     # Without this, --pageset_shuffle + --page_repeat could lead to
     # assertion failures on _started_warm in WillNavigateToPage.
     if cold_runs_percent_set:
       number_warm_pageset_runs = int(
-          (int(pageset_repeat) - 1) * (100 - cold_load_percent) / 100)
-      number_warm_runs = number_warm_pageset_runs * page_repeat
-      self._cold_run_start_index = number_warm_runs + page_repeat
-      self._discard_first_result = (not cold_load_percent or
-                                    self._discard_first_result)
+          (int(args.pageset_repeat) - 1) * (100 - args.cold_load_percent) / 100)
+      number_warm_runs = number_warm_pageset_runs * args.page_repeat
+      cls._cold_run_start_index = number_warm_runs + args.page_repeat
+      cls.discard_first_result = (not args.cold_load_percent or
+                                  cls.discard_first_result)
     else:
-      self._cold_run_start_index = pageset_repeat * page_repeat
+      cls._cold_run_start_index = args.pageset_repeat * args.page_repeat
 
   def WillStartBrowser(self, platform):
     """Initialize metrics once right before the browser has been launched."""
     self._power_metric = power.PowerMetric(platform)
 
   def DidStartBrowser(self, browser):
     """Initialize metrics once right after the browser has been launched."""
     self._memory_metric = memory.MemoryMetric(browser)
     self._cpu_metric = cpu.CpuMetric(browser)
     if self._record_v8_object_stats:
@@ skipping 78 matching lines @@
 
   def ShouldRunCold(self, url):
     # We do the warm runs first for two reasons.  The first is so we can
     # preserve any initial profile cache for as long as possible.
     # The second is that, if we did cold runs first, we'd have a transition
     # page set during which we wanted the run for each URL to both
     # contribute to the cold data and warm the catch for the following
     # warm run, and clearing the cache before the load of the following
     # URL would eliminate the intended warmup for the previous URL.
     return (self._has_loaded_page[url] >= self._cold_run_start_index)