telemetry: Add GetRendererProcessFromTab to timeline model.

tools/perf/metrics/smoothness_unittest.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 random
 import unittest
 
 from metrics import smoothness
 from metrics import statistics
 from metrics import rendering_stats
-from telemetry.core.backends.chrome.tracing_backend import RawTraceResultImpl
-from telemetry.core.backends.chrome.trace_result import TraceResult
+from telemetry.core.backends.chrome.tracing_backend import RawTraceResult

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

this is a no-no.

you should be able to construct a TimelineModel directly from events.

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

crbug.com/314877

 from telemetry.page import page
 from telemetry.page.page_measurement_results import PageMeasurementResults
 
 SYNTHETIC_GESTURE_MARKER = 'SyntheticGestureController::running'
+RENDERER_PROCESS_MARKER = 'RendererProcessMarker'
 
 
 class MockTimer(object):
   """A mock timer class which can generate random durations.
 
   An instance of this class is used as a global timer to generate random
   durations for stats and consistent timestamps for all mock trace events.
   """
   def __init__(self):
     self.microseconds = 0
@@ skipping 57 matching lines @@
              'ts': self.end,
              'cat': 'benchmark',
              's': 't',
              'tid': 11,
              'ph': 'i',
              'args': {'data': self.impl_stats}}
     trace_events.append(event)
 
 
 class SmoothnessMetricUnitTest(unittest.TestCase):
   def testCalcResultsTraceEvents(self):

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

there's something confusing here. This is a test that blurs testing of rendering
stats calculation from a timeline model from the operation of the metric object.

In my head, there should be a test of the metric object that uses a mocked tabs
and verifies that the right calls are made on the tabs etc.

Then there should be a test of the rendering stats that is checked in to a
rendering_stats_unittest.py and should operate purely on timeline model with a
passed in tab instance.

Where the tab instance is just a mock in all cases.

Again I wont block this patch on this but I am seeing too many strange changes
happening in this group of files that suggests we've grown a kind of spaghetti.

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

Yes, the unittest has a pasta flavor -> crbug.com/314877

     # Make the test repeatable by seeding the random number generator
     # (which is used by the mock timer) with a constant number.
     random.seed(1234567)
     mock_timer = MockTimer()
     trace_events = []
     total_time_seconds = 0.0
     num_frames_sent = 0.0

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

as a bit of a comment, I think possibly the test is written a bit oddly...
you're having to create actual trace events. A simpler way would be to create a
TimelineModel yourself and populate it by adding data to the model. If you think
about it, this is testing the analysis of model not the trace parser. Thats what
we do in trace-viewer too (we didn't always, we started by writign out trace
events, but it became a lot cleaner when we made models).

you dont have to block this patch on this feedback but its sorta a passing
comment.

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

crbug.com/314877

     first_frame = True
     previous_frame_time = None
     # This list represents time differences between frames in milliseconds.
     expected_frame_times = []
 
     # Append start trace events for the timeline marker and gesture marker,
     # with some amount of time in between them.
-    trace_events.append({'name': rendering_stats.RENDER_PROCESS_MARKER,
+    trace_events.append({'name': RENDERER_PROCESS_MARKER,
                          'tts': mock_timer.microseconds,
                          'args': {},
                          'pid': 20978,
                          'ts': mock_timer.microseconds,
                          'cat': 'webkit',
                          'tid': 11,
                          'ph': 'S',  # Phase: start.
                          'id': '0x12345'})
     mock_timer.Advance()
     trace_events.append({'name': SYNTHETIC_GESTURE_MARKER,
@@ skipping 30 matching lines @@
     trace_events.append({'name': SYNTHETIC_GESTURE_MARKER,
                          'tts': mock_timer.microseconds,
                          'args': {},
                          'pid': 20978,
                          'ts': mock_timer.microseconds,
                          'cat': 'webkit',
                          'tid': 11,
                          'ph': 'F',  # Phase: finish.
                          'id': '0xabcde'})
     mock_timer.Advance()
-    trace_events.append({'name': rendering_stats.RENDER_PROCESS_MARKER,
+    trace_events.append({'name': RENDERER_PROCESS_MARKER,
                          'tts': mock_timer.microseconds,
                          'args': {},
                          'pid': 20978,
                          'ts': mock_timer.microseconds,
                          'cat': 'webkit',
                          'tid': 11,
                          'ph': 'F',
                          'id': '0x12345'})
 
     # Create a timeline object from the trace.
-    trace_impl = RawTraceResultImpl(trace_events)
-    trace_result = TraceResult(trace_impl)
+    trace_result = RawTraceResult(trace_events)
     timeline = trace_result.AsTimelineModel()
 
     # Find the timeline marker and gesture marker in the timeline,
     # and create a RenderingStats object.
-    render_process_marker = timeline.FindTimelineMarkers(
-        rendering_stats.RENDER_PROCESS_MARKER)
+    renderer_process_markers = timeline.FindTimelineMarkers(
+        RENDERER_PROCESS_MARKER)
+    self.assertEquals(len(renderer_process_markers), 1)
+    renderer_process = renderer_process_markers[0].start_thread.parent
     timeline_markers = timeline.FindTimelineMarkers(
         SYNTHETIC_GESTURE_MARKER)
-    stats = rendering_stats.RenderingStats(
-        render_process_marker, timeline_markers)
+    stats = rendering_stats.RenderingStats(renderer_process, timeline_markers)
 
     # Make a results object and add results to it from the smoothness metric.
     results = PageMeasurementResults()
     results.WillMeasurePage(page.Page('http://foo.com/', None))
-    smoothness_metric = smoothness.SmoothnessMetric(stats)
+    smoothness_metric = smoothness.SmoothnessMetric(None)
+    smoothness_metric.SetStats(stats)
     smoothness_metric.AddResults(None, results)
     results.DidMeasurePage()
 
     self.assertEquals(
         expected_frame_times,
         results.page_results[0]['frame_times'].value)
     self.assertAlmostEquals(
         1000.0 * (total_time_seconds / num_frames_sent),
         results.page_results[0]['mean_frame_time'].value,
         places=2)
 
     # We don't verify the correctness of the discrepancy computation itself,
     # because we have a separate unit test for that purpose.
     self.assertAlmostEquals(
         statistics.FrameDiscrepancy(stats.frame_timestamps, True),
         results.page_results[0]['jank'].value,
         places=4)
 
     # We do not verify the correctness of Percentile here; Percentile should
     # have its own test.
     # The 17 here represents a threshold of 17 ms; this should match the value
     # in the smoothness metric.
     self.assertEquals(
         statistics.Percentile(expected_frame_times, 95.0) < 17.0,
         results.page_results[0]['mostly_smooth'].value)