Update page cycler to differenciate between cold and warm run by default.

tools/perf/measurements/page_cycler.py

 # 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.
 
 """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 23 matching lines @@
     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 = False
     self._report_speed_index = False
     self._speedindex_metric = speedindex.SpeedIndexMetric()
     self._memory_metric = None
     self._cpu_metric = None
     self._v8_object_stats_metric = None
-    self._number_warm_runs = None
-    self._cold_runs_requested = False
     self._cold_run_start_index = None
     self._has_loaded_page = collections.defaultdict(int)
 
   def AddCommandLineOptions(self, parser):
     # The page cyclers should default to 10 iterations. In order to change the
     # default of an option, we must remove and re-add it.
     # TODO: Remove this after transition to run_benchmark.
     pageset_repeat_option = parser.get_option('--pageset-repeat')
     pageset_repeat_option.default = 10
     parser.remove_option('--pageset-repeat')
@@ skipping 53 matching lines @@
 
     # A disk cache bug causes some page cyclers to hang on mac.
     # TODO(tonyg): Re-enable these tests when crbug.com/268646 is fixed.
     if (sys.platform == 'darwin' and
         (sys.argv[-1].endswith('/intl_hi_ru.json') or
          sys.argv[-1].endswith('/tough_layout_cases.json') or
          sys.argv[-1].endswith('/typical_25.json'))):
       print '%s is currently disabled on mac. Skipping test.' % sys.argv[-1]
       sys.exit(0)
 
-    self._cold_runs_requested = (options.cold_load_percent != None)
+    cold_runs_percent_set = (options.cold_load_percent != None)
     # Handle requests for cold cache runs
-    if (self._cold_runs_requested and
+    if (cold_runs_percent_set and
         (options.repeat_options.page_repeat_secs or
          options.repeat_options.pageset_repeat_secs)):
       raise Exception('--cold-load-percent is incompatible with timed repeat')
 
-    if (self._cold_runs_requested and
+    if (cold_runs_percent_set and
         (options.cold_load_percent < 0 or options.cold_load_percent > 100)):
       raise Exception('--cold-load-percent must be in the range [0-100]')
 
-    # TODO(rdsmith): Properly handle interaction of page_repeat with
-    # dropping the first run.
-    number_warm_pageset_runs = int(
-        (int(options.repeat_options.pageset_repeat_iters) - 1) *
-        (100 - int(options.cold_load_percent or 0)) / 100)
-
-    # Make sure _number_cold_runs is an integer multiple of page_repeat.
+    # 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.
-    self._number_warm_runs = (number_warm_pageset_runs *
-                              options.repeat_options.page_repeat_iters)
-    self._cold_run_start_index = (self._number_warm_runs +
-        options.repeat_options.page_repeat_iters)
-    self.discard_first_result = ((self._cold_runs_requested and
-                                  not options.cold_load_percent) or
-                                 self.discard_first_result)
+    if cold_runs_percent_set:
+      number_warm_pageset_runs = int(
+          (int(options.repeat_options.pageset_repeat_iters) - 1) *
+          (100 - options.cold_load_percent) / 100)
+      number_warm_runs = (number_warm_pageset_runs *
+                          options.repeat_options.page_repeat_iters)
+      self._cold_run_start_index = (number_warm_runs +
+          options.repeat_options.page_repeat_iters)
+      self.discard_first_result = (not options.cold_load_percent or
+                                   self.discard_first_result)
+    else:
+      self._cold_run_start_index = (
+          options.repeat_options.pageset_repeat_iters *
+          options.repeat_options.page_repeat_iters)
 
   def MeasurePage(self, page, tab, results):
     tab.WaitForJavaScriptExpression('__pc_load_time', 60)
 
-    chart_name_prefix = ('' if not self._cold_runs_requested else
-                         'cold_' if self.IsRunCold(page.url) else
+    chart_name_prefix = ('cold_' if self.IsRunCold(page.url) else
                          'warm_')
 
     results.Add('page_load_time', 'ms',
                 int(float(tab.EvaluateJavaScript('__pc_load_time'))),
                 chart_name=chart_name_prefix+'times')
 
     self._has_loaded_page[page.url] += 1
 
     self._memory_metric.Stop(page, tab)
     self._memory_metric.AddResults(tab, results)
@@ skipping 12 matching lines @@
       self._speedindex_metric.Stop(page, tab)
       self._speedindex_metric.AddResults(
           tab, results, chart_name=chart_name_prefix+'speed_index')
 
   def DidRunTest(self, browser, results):
     self._memory_metric.AddSummaryResults(results)
     io.IOMetric().AddSummaryResults(browser, results)
 
   def IsRunCold(self, url):
     return (self.ShouldRunCold(url) or
-            (self._cold_runs_requested and
-             self._has_loaded_page[url] == 0))
+            self._has_loaded_page[url] == 0)
 
   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._cold_runs_requested and
-            self._has_loaded_page[url] >= self._cold_run_start_index)
+    return (self._has_loaded_page[url] >= self._cold_run_start_index)
 
   def results_are_the_same_on_every_page(self):
-    return not self._cold_runs_requested
+    return False