telemetry: Add GetRendererProcessFromTab to timeline model.

tools/perf/metrics/smoothness.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be

[nduca, 2013/10/31 07:32:02]

i'm pretty sure there are other uses in perf/ that use this trick please make
sure you convert them all

 # found in the LICENSE file.
 
 from metrics import Metric
 from metrics import rendering_stats
 from metrics import statistics
 from telemetry.core.timeline.model import MarkerMismatchError
 from telemetry.core.timeline.model import MarkerOverlapError
 from telemetry.page import page_measurement
 
-TIMELINE_MARKER = 'SmoothnessMetric'
+TIMELINE_MARKER = 'Smoothness'
 
 
 class NotEnoughFramesError(page_measurement.MeasurementFailure):
   def __init__(self):
     super(NotEnoughFramesError, self).__init__(
         'Page output less than two frames')
 
 
 class NoSupportedActionError(page_measurement.MeasurementFailure):
   def __init__(self):
@@ skipping 21 matching lines @@
 
   def Start(self, page, tab):
     # TODO(ermst): Remove "webkit" category after Blink r157377 is picked up by
     # the reference builds.
     tab.browser.StartTracing('webkit,webkit.console,benchmark', 60)
     tab.ExecuteJavaScript('console.time("' + TIMELINE_MARKER + '")')
 
   def Stop(self, page, tab):
     tab.ExecuteJavaScript('console.timeEnd("' + TIMELINE_MARKER + '")')
     timeline_model = tab.browser.StopTracing().AsTimelineModel()
-    render_process_marker = timeline_model.FindTimelineMarkers(TIMELINE_MARKER)
+    smoothness_marker = timeline_model.FindTimelineMarkers(TIMELINE_MARKER)
     timeline_marker_labels = GetTimelineMarkerLabelsFromAction(

[nduca, 2013/10/31 07:32:02]

Labels is a bit funky. TimelineEvents have names, right, not labels. Maybe my
fault in suggeseting this name.

[ernstm, 2013/11/05 00:25:05]

Done.

         self._compound_action)
     try:
       timeline_markers = timeline_model.FindTimelineMarkers(
           timeline_marker_labels)
     except MarkerMismatchError:
       # TODO(ernstm): re-raise exception as MeasurementFailure when the
       # reference build was updated.
-      timeline_markers = render_process_marker
+      timeline_markers = smoothness_marker
     except MarkerOverlapError as e:
       raise page_measurement.MeasurementFailure(str(e))
 
+    renderer_process = timeline_model.GetRendererProcessFromTab(tab)
     self._stats = rendering_stats.RenderingStats(
-        render_process_marker, timeline_markers)
+        renderer_process, timeline_markers)
 
     if not self._stats.frame_times:
       raise NotEnoughFramesError()
 
+  def SetStats(self, stats):

[nduca, 2013/10/31 07:32:02]

This isn't quite the right direction to be pursuing for unit tests and exposes
some architectural flaws that make testing hard. Often times when you find
yourself adding a method here you should step back and figure out whats going
wrong in your architecture that exposes the need for such a test-specific call.

I think the thing that goes wrong here is that that the
RenderingStats<->TimelineModel interface isn't very well defined. 

Stop should be stashing away timeline_marker_labels and the TimelineModel. You
can compute a RenderingStats results completely from labels. And you can dump
RenderingStats to a results object entirely without needing the tab, or any
fields on the Metric object.

In my mind, SmoothnessMetrics.AddResults() should be a simple function that says
literally two lines:
 stats = RenderingStats(self._timeline_model,
filter_by=self._timeline_marker_labels)
 stats.AddResults(results)

The bulk of Addresults, I think belongs in RenderingStats.

Then, the unit tests of this class should just test that the test is making the
right calls --- by creating a *real* browser and verifying simply that this code
does't crash.

The rest of the testing shoudl then go to RenderingStats where you give it an
already-created model, and verify that the numbers it computes are correct, AND
that the nubmers added to the results are correct.

[ernstm, 2013/11/05 00:25:05]

I agree that smoothness_unittest.py needs a major overhaul. Filed
crbug.com/314877 and will address in a separate patch.

I don't think we should have AddResults() on RenderingStats, though.
RenderingStats extracts the raw stats from a trace. Metrics use it to compute
higher-level statistical measures and add those to the results object. Different
metrics compute different statistical measures.

+    """ Pass in a RenderingStats object directly. For unittests that don't call
+        Start/Stop.
+    """
+    self._stats = stats
 
   def AddResults(self, tab, results):
     # List of raw frame times.
     results.Add('frame_times', 'ms', self._stats.frame_times)
 
     # Arithmetic mean of frame times.
     mean_frame_time = statistics.ArithmeticMean(self._stats.frame_times,
                                                 len(self._stats.frame_times))
     results.Add('mean_frame_time', 'ms', round(mean_frame_time, 3))
 
     # Absolute discrepancy of frame time stamps.
     jank = statistics.FrameDiscrepancy(self._stats.frame_timestamps)
     results.Add('jank', '', round(jank, 4))
 
     # Are we hitting 60 fps for 95 percent of all frames? (Boolean value)
     # We use 17ms as a slightly looser threshold, instead of 1000.0/60.0.
     results.Add('mostly_smooth', '',
         statistics.Percentile(self._stats.frame_times, 95.0) < 17.0)