Drop DidStartHTTPServer to simplify object interactions.

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 27 matching lines @@
     with open(os.path.join(os.path.dirname(__file__),
                            'page_cycler.js'), 'r') as f:
       self._page_cycler_js = f.read()
 
     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
 
   @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.')
@@ skipping 29 matching lines @@
     """Initialize metrics once right before the browser has been launched."""
     self._power_metric = power.PowerMetric(browser)
 
   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:
       self._v8_object_stats_metric = v8_object_stats.V8ObjectStatsMetric()
 
-  def DidStartHTTPServer(self, tab):
-    # Avoid paying for a cross-renderer navigation on the first page on legacy
-    # page cyclers which use the filesystem.
-    tab.Navigate(tab.browser.http_server.UrlOf('nonexistent.html'))
+  def WillNavigateToPage(self, page, tab):
+    if page.is_file:

[tonyg, 2014/09/11 22:13:15]

Looks like this'll work. An alternate approach would be to set
discard_first_result and add the nonexistent.html page as the first page of the
page sets in question (everything in tools/perf/page_sets/page_cycler/*). That
might be cleaner for now, although, Ned might know better whether there are
plans to get rid of that option or not.

+      # For legacy page cyclers which use the filesystem, do an initial
+      # navigate to avoid paying for a cross-renderer navigation.
+      initial_url = tab.browser.http_server.UrlOf('nonexistent.html')
+      if self._initial_renderer_url != initial_url:
+        self._initial_renderer_url = initial_url
+        tab.Navigate(self._initial_renderer_url)
 
-  def WillNavigateToPage(self, page, tab):
     page.script_to_evaluate_on_commit = self._page_cycler_js
     if self.ShouldRunCold(page.url):
       tab.ClearCache(force=True)
     if self._report_speed_index:
       self._speedindex_metric.Start(page, tab)
     self._cpu_metric.Start(page, tab)
     self._power_metric.Start(page, tab)
 
   def DidNavigateToPage(self, page, tab):
     self._memory_metric.Start(page, tab)
@@ skipping 57 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)