tools/android/loading: Archive tracks in LoadingTrace.

tools/android/loading/tracing.py

 # Copyright 2016 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.
 
 """Monitor tracing events on chrome via chrome remote debugging."""
 
 import bisect
 import itertools
 
 import devtools_monitor
@@ skipping 10 matching lines @@
     Args:
       connection: a DevToolsConnection.
       categories: None, or a string, or list of strings, of tracing categories
         to filter.
 
       fetch_stream: if true, use a websocket stream to fetch tracing data rather
         than dataCollected events. It appears based on very limited testing that
         a stream is slower than the default reporting as dataCollected events.
     """
     super(TracingTrack, self).__init__(connection)
-    connection.RegisterListener('Tracing.dataCollected', self)
+    if connection:

[mattcary, 2016/01/19 15:24:47]

Generally I try to minimize testing-specific tweaks like this. I've found it's
better to go through the slight pain of setting up an appropriate mock for a
unittest, then to have production code silently fail because one has forgotten
to initialize something.

But in this case it doesn't matter much yet, so I don't really care.

[Benoit L, 2016/01/19 15:54:50]

I agree. But in this instance this is not for testing only. Since the tracks do
processing themselves, then we need to reconstruct them from a JSON file. In
this case, there is no valid connection. So a track need to be useful without
it. However this could be more elegant.
Thoughts?

+      connection.RegisterListener('Tracing.dataCollected', self)
     params = {}
     if categories:
       params['categories'] = (categories if type(categories) is str
                               else ','.join(categories))
     if fetch_stream:
       params['transferMode'] = 'ReturnAsStream'
 
-    connection.SyncRequestNoResponse('Tracing.start', params)
+    if connection:
+      connection.SyncRequestNoResponse('Tracing.start', params)
     self._events = []
 
     self._event_msec_index = None
     self._event_lists = None
 
   def Handle(self, method, event):
     for e in event['params']['value']:
       self._events.append(Event(e))
     # Just invalidate our indices rather than trying to be fancy and
     # incrementally update.
@@ skipping 19 matching lines @@
     self._IndexEvents()
     idx = bisect.bisect_right(self._event_msec_index, msec) - 1
     if idx < 0:
       return []
     events = self._event_lists[idx]
     assert events.start_msec <= msec
     if not events or events.end_msec < msec:
       return []
     return events.event_list
 
+
+  def ToJsonDict(self):
+    return {'events': [e.ToJsonDict() for e in self._events]}
+
+  @classmethod
+  def FromJsonDict(cls, json_dict):
+    assert 'events' in json_dict
+    events = [Event(e) for e in json_dict['events']]
+    tracing_track = TracingTrack(None)
+    tracing_track._events = events
+    return tracing_track
+
   def _IndexEvents(self):
     """Computes index for in-flight events.
 
     Creates a list of timestamps where events start or end, and tracks the
     current set of in-flight events at the instant after each timestamp. To do
     this we have to synthesize ending events for complete events, as well as
     join and track the nesting of async, flow and other spanning events.
 
     Events such as instant and counter events that aren't indexable are skipped.
 
@@ skipping 179 matching lines @@
     if not synthetic and tracing_event['ph'] in ['p']:
       raise devtools_monitor.DevToolsConnectionException(
           'Deprecated event: %s' % tracing_event)
 
     self._tracing_event = tracing_event
     # Note tracing event times are in microseconds.
     self._start_msec = tracing_event['ts'] / 1000.0
     self._end_msec = None
     self._synthetic = synthetic
     if self.type == 'X':
-      self._end_msec = self.start_msec + tracing_event['dur'] / 1000.0
+      # Some events don't have a duration.
+      duration = (tracing_event['dur']
+                  if 'dur' in tracing_event else tracing_event['tdur'])
+      self._end_msec = self.start_msec + duration / 1000.0
 
   @property
   def start_msec(self):
     return self._start_msec
 
   @property
   def end_msec(self):
     return self._end_msec
 
   @property
@@ skipping 60 matching lines @@
         'Bad closing: %s --> %s' % (self, closing))
     if self.type in ['b', 'S'] and (
         self.tracing_event['cat'] != closing.tracing_event['cat'] or
         self.id != closing.id):
       raise devtools_monitor.DevToolsConnectionException(
         'Bad async closing: %s --> %s' % (self, closing))
     self._end_msec = closing.start_msec
     if 'args' in closing.tracing_event:
       self.tracing_event.setdefault(
           'args', {}).update(closing.tracing_event['args'])
+
+  def ToJsonDict(self):
+    return self._tracing_event
+
+  @classmethod
+  def FromJsonDict(cls, json_dict):
+    return Event(json_dict)