Move timeline and importers to use telemetry.value.TraceValue

tools/perf/metrics/speedindex_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.
 
 # These tests access private methods in the speedindex module.
 # pylint: disable=W0212
 
 import json
 import os
 import unittest
 
 from telemetry.core import bitmap
-from telemetry.timeline import inspector_timeline_data
 from telemetry.timeline import model
+from telemetry.value import trace as trace_value_module
 from metrics import speedindex
 
 # Sample timeline data in the json format provided by devtools.
 # The sample events will be used in several tests below.
+
 _TEST_DIR = os.path.join(os.path.dirname(__file__), 'unittest_data')
-_SAMPLE_DATA = json.load(open(os.path.join(_TEST_DIR, 'sample_timeline.json')))
-_SAMPLE_TIMELINE_DATA = inspector_timeline_data.InspectorTimelineData(
-    _SAMPLE_DATA)
-_SAMPLE_EVENTS = model.TimelineModel(
-    timeline_data=_SAMPLE_TIMELINE_DATA).GetAllEvents()
+
+def _GetSampleEvents():
+  with open(os.path.join(_TEST_DIR, 'sample_timeline.json') as f:
+    data = json.load(f)
+  builder = trace_value_module.TraceValueBuilder()
+  builder.AddEventsTo(trace_value_module.INSPECTOR_TRACE_PART, data)
+  model = model.TimelineModel(builder.AsValue())
+  return model.GetAllEvents()
 
 
 class FakeTimelineModel(object):
 
   def __init__(self):
     self._events = []
 
-  def SetAllEvents(self, events):
+  def SetAllEventsOnFake(self, events):
     self._events = events
 
   def GetAllEvents(self, recursive=True):
     assert recursive == True
     return self._events
 
 
 class FakeVideo(object):
 
   def __init__(self, frames):
@@ skipping 44 matching lines @@
 
   def Highlight(self, _):
     pass
 
 
 class IncludedPaintEventsTest(unittest.TestCase):
   def testNumberPaintEvents(self):
     impl = speedindex.PaintRectSpeedIndexImpl()
     # In the sample data, there's one event that occurs before the layout event,
     # and one paint event that's not a leaf paint event.
-    events = impl._IncludedPaintEvents(_SAMPLE_EVENTS)
+    events = impl._IncludedPaintEvents(_GetSampleEvents())
     self.assertEqual(len(events), 5)
 
 
 class SpeedIndexImplTest(unittest.TestCase):
   def testAdjustedAreaDict(self):
     impl = speedindex.PaintRectSpeedIndexImpl()
-    paint_events = impl._IncludedPaintEvents(_SAMPLE_EVENTS)
+    paint_events = impl._IncludedPaintEvents(_GetSampleEvents())
     viewport = 1000, 1000
     time_area_dict = impl._TimeAreaDict(paint_events, viewport)
     self.assertEqual(len(time_area_dict), 4)
     # The event that ends at time 100 is a fullscreen; it's discounted by half.
     self.assertEqual(time_area_dict[100], 500000)
     self.assertEqual(time_area_dict[300], 100000)
     self.assertEqual(time_area_dict[400], 200000)
     self.assertEqual(time_area_dict[800], 200000)
 
   def testVideoCompleteness(self):
@@ skipping 54 matching lines @@
     viewport = 1000, 1000
     # Add up the parts of the speed index for each time interval.
     # Each part is the time interval multiplied by the proportion of the
     # total area value that is not yet painted for that interval.
     parts = []
     parts.append(100 * 1.0)
     parts.append(200 * 0.5)
     parts.append(100 * 0.4)
     parts.append(400 * 0.2)
     expected = sum(parts)  # 330.0
-    tab.timeline_model.SetAllEvents(_SAMPLE_EVENTS)
+    tab.timeline_model.SetAllEventsOnFake(_GetSampleEvents())
     tab.SetEvaluateJavaScriptResult(viewport)
     actual = impl.CalculateSpeedIndex(tab)
     self.assertEqual(actual, expected)
 
 
 class WPTComparisonTest(unittest.TestCase):
   """Compare the speed index results with results given by webpagetest.org.
 
   Given the same timeline data, both this speedindex metric and webpagetest.org
   should both return the same results. Fortunately, webpagetest.org also
   provides timeline data in json format along with the speed index results.
   """
 
   def _TestJsonTimelineExpectation(self, filename, viewport, expected):
     """Check whether the result for some timeline data is as expected.
 
     Args:
       filename: Filename of a json file which contains a
       expected: The result expected based on the WPT result.
     """
     tab = FakeTab()
     impl = speedindex.PaintRectSpeedIndexImpl()
     file_path = os.path.join(_TEST_DIR, filename)
     with open(file_path) as json_file:
       raw_events = json.load(json_file)
-      timeline_data = inspector_timeline_data.InspectorTimelineData(raw_events)
-      tab.timeline_model.SetAllEvents(
-          model.TimelineModel(timeline_data=timeline_data).GetAllEvents())
+      builder = trace_value_module.TraceValueBuilder()
+      builder.AddEventsTo(trace_value_module.INSPECTOR_TRACE_PART, raw_events)
+      all_events = model.TimelineModel(builder.AsValue()).GetAllEvents()
+      tab.timeline_model.SetAllEventsOnFake()
       tab.SetEvaluateJavaScriptResult(viewport)
       actual = impl.CalculateSpeedIndex(tab)
       # The result might differ by 1 or more milliseconds due to rounding,
       # so compare to the nearest 10 milliseconds.
       self.assertAlmostEqual(actual, expected, places=-1)
 
   def testCern(self):
     # Page: http://info.cern.ch/hypertext/WWW/TheProject.html
     # This page has only one paint event.
     self._TestJsonTimelineExpectation(
         'cern_repeat_timeline.json', (1014, 650), 379.0)
 
   def testBaidu(self):
     # Page: http://www.baidu.com/
     # This page has several paint events, but no nested paint events.
     self._TestJsonTimelineExpectation(
         'baidu_repeat_timeline.json', (1014, 650), 1761.43)
 
   def test2ch(self):
     # Page: http://2ch.net/
     # This page has several paint events, including nested paint events.
     self._TestJsonTimelineExpectation(
         '2ch_repeat_timeline.json', (997, 650), 674.58)
 
 
 if __name__ == "__main__":
   unittest.main()