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.trace_result import TraceResult
+from telemetry.core.backends.chrome.tracing_backend import ChromeRawTraceResult
 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 72 matching lines @@
     trace_events = []
     total_time_seconds = 0.0
     num_frames_sent = 0.0
     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 = TraceResult(ChromeRawTraceResult(trace_events, None))
     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)