[Telemetry] Adding Memory Timeline Metric

tools/telemetry/telemetry/timeline/model.py

 # Copyright 2014 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.
 """A container for timeline-based events and traces and can handle importing
 raw event data from different sources. This model closely resembles that in the
 trace_viewer project:
 https://code.google.com/p/trace-viewer/
 """
 
 from operator import attrgetter
 
 from telemetry.timeline import async_slice as async_slice_module
 from telemetry.timeline import bounds
 from telemetry.timeline import event_container
 from telemetry.timeline import inspector_importer
+from telemetry.timeline import memory_dump_event
 from telemetry.timeline import process as process_module
 from telemetry.timeline import slice as slice_module
 from telemetry.timeline import surface_flinger_importer
 from telemetry.timeline import tab_id_importer
 from telemetry.timeline import trace_data as trace_data_module
 from telemetry.timeline import trace_event_importer
 
 # Register importers for data
 
 _IMPORTERS = [
@@ skipping 36 matching lines @@
     self._thread_time_bounds = {}
     self._processes = {}
     self._browser_process = None
     self._gpu_process = None
     self._surface_flinger_process = None
     self._frozen = False
     self._tab_ids_to_renderer_threads_map = {}
     self.import_errors = []
     self.metadata = []
     self.flow_events = []
+    self._memory_dump_events = None
     if trace_data is not None:
       self.ImportTraces(trace_data, shift_world_to_zero=shift_world_to_zero)
 
+  def SetMemoryDumpEvents(self, memory_dump_events):
+    """Populates the model with a sequence of MemoryDumpEvent objects."""
+    assert not self._frozen and self._memory_dump_events is None
+    # keep events sorted in cronological order
+    self._memory_dump_events = sorted(memory_dump_events,
+                                      key=lambda event: event.start)
+
+  def IterMemoryDumpEvents(self, reverse=False):
+    """Iterate over the memory dump events of this model.
+
+    Args:
+      reverse: A boolean indicating whether to yield events in reversed time
+        order. By default events are generated in chronological order.
+    """
+    if self._memory_dump_events is None:
+      return iter([]) # empty iterator
+    elif reverse:
+      return reversed(self._memory_dump_events)
+    else:
+      return iter(self._memory_dump_events)
+
+  def IterEventsInThisContainer(self, event_type_predicate, event_predicate):
+    if event_type_predicate(memory_dump_event.MemoryDumpEvent):
+      for event in self.IterMemoryDumpEvents():
+        if event_predicate(event):
+          yield event
+
   def IterChildContainers(self):
     for process in self._processes.itervalues():
       yield process
 
   def GetAllProcesses(self):
     return self._processes.values()
 
   def GetAllThreads(self):
     threads = []
     for process in self._processes.values():
@@ skipping 179 matching lines @@
     importers = []
     for part in trace_data.active_parts:
       importer_class = FindImporterClassForPart(part)
       if not importer_class:
         raise Exception('No importer found for %s' % repr(part))
       importers.append(importer_class(self, trace_data))
 
       importers.sort(key=lambda k: k.import_order)
 
     return importers