[Telemetry] Move page quiescence test to WebContents

tools/perf/metrics/speedindex.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 collections
-import os
 
 from metrics import Metric
 from telemetry.core import bitmap
 
 
 class SpeedIndexMetric(Metric):
   """The speed index metric is one way of measuring page load speed.
 
   It is meant to approximate user perception of page load speed, and it
   is based on the amount of time that it takes to paint to the visual
   portion of the screen. It includes paint events that occur after the
   onload event, and it doesn't include time loading things off-screen.
 
   This speed index metric is based on WebPageTest.org (WPT).
   For more info see: http://goo.gl/e7AH5l
   """
   def __init__(self):
     super(SpeedIndexMetric, self).__init__()
     self._impl = None
-    self._script_is_loaded = False
-    self._is_finished = False
-    with open(os.path.join(os.path.dirname(__file__), 'speedindex.js')) as f:
-      self._js = f.read()
 
   @classmethod
   def CustomizeBrowserOptions(cls, options):
     options.AppendExtraBrowserArgs('--disable-infobars')
 
   def Start(self, _, tab):
     """Start recording events.
 
     This method should be called in the WillNavigateToPage method of
     a PageMeasurement, so that all the events can be captured. If it's called
     in DidNavigateToPage, that will be too late.
     """
     self._impl = (VideoSpeedIndexImpl() if tab.video_capture_supported else
                   PaintRectSpeedIndexImpl())
     self._impl.Start(tab)
-    self._script_is_loaded = False
-    self._is_finished = False
 
   def Stop(self, _, tab):
     """Stop timeline recording."""
     assert self._impl, 'Must call Start() before Stop()'
     assert self.IsFinished(tab), 'Must wait for IsFinished() before Stop()'
     self._impl.Stop(tab)
 
   # Optional argument chart_name is not in base class Metric.
   # pylint: disable=W0221
   def AddResults(self, tab, results, chart_name=None):
@@ skipping 14 matching lines @@
     A page may repeatedly request resources in an infinite loop; a timeout
     should be placed in any measurement that uses this metric, e.g.:
       def IsDone():
         return self._speedindex.IsFinished(tab)
       util.WaitFor(IsDone, 60)
 
     Returns:
       True if 2 seconds have passed since last resource received, false
       otherwise.
     """
-    if self._is_finished:
-      return True
-
-    # The script that provides the function window.timeSinceLastResponseMs()
-    # needs to be loaded for this function, but it must be loaded AFTER
-    # the Start method is called, because if the Start method is called in
-    # the PageMeasurement's WillNavigateToPage function, then it will
-    # not be available here. The script should only be re-loaded once per page
-    # so that variables in the script get reset only for a new page.
-    if not self._script_is_loaded:
-      tab.ExecuteJavaScript(self._js)
-      self._script_is_loaded = True
-
-    time_since_last_response_ms = tab.EvaluateJavaScript(
-        "window.timeSinceLastResponseAfterLoadMs()")
-    self._is_finished = time_since_last_response_ms > 2000
-    return self._is_finished
+    return tab.HasReachedQuiescence()
 
 
 class SpeedIndexImpl(object):
 
   def Start(self, tab):
     raise NotImplementedError()
 
   def Stop(self, tab):
     raise NotImplementedError()
 
@@ skipping 210 matching lines @@
     frame = paint_event.args['frameId']
     return (frame,) + GetBox(paint_event.args['data']['clip'])
 
   def _GroupEventByRectangle(self, paint_events):
     """Group all paint events according to the rectangle that they update."""
     result = collections.defaultdict(list)
     for event in paint_events:
       assert event.name == 'Paint'
       result[self._GetRectangle(event)].append(event)
     return result