Move timeline and importers to use telemetry.value.TraceValue

tools/telemetry/telemetry/timeline/trace_event_importer.py

Index: tools/telemetry/telemetry/timeline/trace_event_importer.py
diff --git a/tools/telemetry/telemetry/timeline/trace_event_importer.py b/tools/telemetry/telemetry/timeline/trace_event_importer.py
index a15beb29e531a532fe714e8829f97a498320083a..41a577e1268c31af95dcbcd5cc28a6491178dc1d 100644
--- a/tools/telemetry/telemetry/timeline/trace_event_importer.py
+++ b/tools/telemetry/telemetry/timeline/trace_event_importer.py
@@ -12,95 +12,36 @@ import json
 import re
 
 from telemetry.timeline import importer
-from telemetry.timeline import tracing_timeline_data
 import telemetry.timeline.async_slice as tracing_async_slice
 import telemetry.timeline.flow_event as tracing_flow_event
-
-
-class TraceBufferOverflowException(Exception):
-  pass
+import telemetry.value.trace as trace_value_module
 
 
 class TraceEventTimelineImporter(importer.TimelineImporter):
-  def __init__(self, model, timeline_data):
+  def __init__(self, model, trace_value):
     super(TraceEventTimelineImporter, self).__init__(
-        model, timeline_data, import_priority=1)
-
-    event_data = timeline_data.EventData()
+        model,
+        trace_value,
+        import_order=1)
+    assert isinstance(trace_value, trace_value_module.TraceValue)
+    self._trace_value = trace_value
 
-    self._events_were_from_string = False
     self._all_async_events = []
     self._all_object_events = []
     self._all_flow_events = []
 
-    if type(event_data) is str:
-      # If the event data begins with a [, then we know it should end with a ].
-      # The reason we check for this is because some tracing implementations
-      # cannot guarantee that a ']' gets written to the trace file. So, we are
-      # forgiving and if this is obviously the case, we fix it up before
-      # throwing the string at JSON.parse.
-      if event_data[0] == '[':
-        event_data = re.sub(r'[\r|\n]*$', '', event_data)
-        event_data = re.sub(r'\s*,\s*$', '', event_data)
-        if event_data[-1] != ']':
-          event_data = event_data + ']'
-
-      self._events = json.loads(event_data)
-      self._events_were_from_string = True
-    else:
-      self._events = event_data
-
-    # Some trace_event implementations put the actual trace events
-    # inside a container. E.g { ... , traceEvents: [ ] }
-    # If we see that, just pull out the trace events.
-    if 'traceEvents' in self._events:
-      container = self._events
-      self._events = self._events['traceEvents']
-      for field_name in container:
-        if field_name == 'traceEvents':
-          continue
-
-        # Any other fields in the container should be treated as metadata.
-        self._model.metadata.append({
-            'name' : field_name,
-            'value' : container[field_name]})
+    self._events = trace_value.GetEventsFor(
+        trace_value_module.CHROME_TRACE_PART)
 
   @staticmethod
-  def CanImport(timeline_data):
-    ''' Returns whether obj is a TraceEvent array. '''
-    if not isinstance(timeline_data,
-                      tracing_timeline_data.TracingTimelineData):
-      return False
-
-    event_data = timeline_data.EventData()
-
-    # May be encoded JSON. But we dont want to parse it fully yet.
-    # Use a simple heuristic:
-    #   - event_data that starts with [ are probably trace_event
-    #   - event_data that starts with { are probably trace_event
-    # May be encoded JSON. Treat files that start with { as importable by us.
-    if isinstance(event_data, str):
-      return len(event_data) > 0 and (event_data[0] == '{'
-          or event_data[0] == '[')
-
-    # Might just be an array of events
-    if (isinstance(event_data, list) and len(event_data)
-        and 'ph' in event_data[0]):
-      return True
-
-    # Might be an object with a traceEvents field in it.
-    if 'traceEvents' in event_data:
-      trace_events = event_data.get('traceEvents', None)
-      return (type(trace_events) is list and
-          len(trace_events) > 0 and 'ph' in trace_events[0])
-
-    return False
+  def GetSupportedPart():
+    return trace_value_module.CHROME_TRACE_PART
 
   def _GetOrCreateProcess(self, pid):
     return self._model.GetOrCreateProcess(pid)
 
   def _DeepCopyIfNeeded(self, obj):
-    if self._events_were_from_string:
+    if self._trace_value.events_are_safely_mutable:
       return obj
     return copy.deepcopy(obj)
 
@@ -286,7 +227,6 @@ class TraceEventTimelineImporter(importer.TimelineImporter):
     self._SetBrowserProcess()
     self._CreateExplicitObjects()
     self._CreateImplicitObjects()
-    self._CreateTabIdsToThreadsMap()
 
   def _CreateAsyncSlices(self):
     if len(self._all_async_events) == 0:
@@ -457,32 +397,4 @@ class TraceEventTimelineImporter(importer.TimelineImporter):
   def _SetBrowserProcess(self):
     for thread in self._model.GetAllThreads():
       if thread.name == 'CrBrowserMain':
-        self._model.browser_process = thread.parent
-
-  def _CheckTraceBufferOverflow(self):
-    for process in self._model.GetAllProcesses():
-      if process.trace_buffer_did_overflow:
-        raise TraceBufferOverflowException(
-            'Trace buffer of process with pid=%d overflowed at timestamp %d. '
-            'Raw trace data:\n%s' %
-            (process.pid, process.trace_buffer_overflow_event.start,
-             repr(self._events)))
-
-  def _CreateTabIdsToThreadsMap(self):
-    # Since _CreateTabIdsToThreadsMap() relies on markers output on timeline
-    # tracing data, it maynot work in case we have trace events dropped due to
-    # trace buffer overflow.
-    self._CheckTraceBufferOverflow()
-
-    tab_ids_list = []
-    for metadata in self._model.metadata:
-      if metadata['name'] == 'tabIds':
-        tab_ids_list = metadata['value']
-        break
-    for tab_id in tab_ids_list:
-      timeline_markers = self._model.FindTimelineMarkers(tab_id)
-      assert(len(timeline_markers) == 1)
-      assert(timeline_markers[0].start_thread ==
-             timeline_markers[0].end_thread)
-      self._model.AddMappingFromTabIdToRendererThread(
-          tab_id, timeline_markers[0].start_thread)
+        self._model.browser_process = thread.parent