Add GetThreadToInteractionRecordsMapsFromModel method to timeline_interaction_record.

tools/telemetry/telemetry/web_perf/timeline_based_measurement.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.
 
 import logging
 import os
 
 from collections import defaultdict
 from telemetry.core import util
 from telemetry.core.backends.chrome import tracing_backend
@@ skipping 47 matching lines @@
     return self._results.current_page
 
   def _GetResultName(self, trace_name):
     return '%s-%s' % (self._result_prefix, trace_name)
 
   def AddValue(self, value):
     value.name = self._GetResultName(value.name)
     self._results.AddValue(value)
 
 class _TimelineBasedMetrics(object):
-  def __init__(self, model, renderer_thread,
-               get_metric_from_metric_type_callback):
+  def __init__(self, model, get_metric_from_metric_type_callback):
     self._model = model
-    self._renderer_thread = renderer_thread
     self._get_metric_from_metric_type_callback = \
         get_metric_from_metric_type_callback
 
   def FindTimelineInteractionRecords(self):
     # TODO(nduca): Add support for page-load interaction record.
-    return [tir_module.TimelineInteractionRecord.FromAsyncEvent(event) for
-            event in self._renderer_thread.async_slices
-            if tir_module.IsTimelineInteractionRecord(event.name)]
+    threads_to_records_map = (
+        tir_module.GetThreadToInteractionRecordsMapsFromModel(self._model))
+    #TODO(nednguyen) support multiple records on multiple threads
+    assert len(threads_to_records_map) == 1, (
+        'TimelineBasedMeasurement only support interaction records issued'
+        ' from a single thread.')
+    return threads_to_records_map.values[0]
 
   def AddResults(self, results):
     all_interactions = self.FindTimelineInteractionRecords()
     if len(all_interactions) == 0:
       raise InvalidInteractions('Expected at least one interaction record on '
                                 'the page')
 
     interactions_by_label = defaultdict(list)
     for i in all_interactions:
       interactions_by_label[i.label].append(i)
@@ skipping 11 matching lines @@
       # For each metric type, either all or none of the interactions should
       # have that metric.
       interactions_with_metric = [i for i in interactions if
                                   i.HasMetric(metric_type)]
       if not interactions_with_metric:
         continue
       if len(interactions_with_metric) != len(interactions):
         raise InvalidInteractions('Interaction records with the same logical '
                                   'name must have the same flags.')
       metric = self._get_metric_from_metric_type_callback(metric_type)
-      metric.AddResults(self._model, self._renderer_thread,
-                        interactions, wrapped_results)
+      metric.AddResults(self._model, interactions, wrapped_results)
 
 
 class TimelineBasedMeasurement(page_measurement.PageMeasurement):
   """Collects multiple metrics pages based on their interaction records.
 
   A timeline measurement shifts the burden of what metrics to collect onto the
   page under test, or the pageset running that page. Instead of the measurement
   having a fixed set of values it collects about the page, the page being tested
   issues (via javascript) an Interaction record into the user timing API that
   describing what the page is doing at that time, as well as a standardized set
@@ skipping 50 matching lines @@
           os.path.join(trace_dir, 'trace')) + '.json'
       try:
         with open(trace_file_path, 'w') as f:
           trace_result.Serialize(f)
         results.AddValue(string_value_module.StringValue(
             page, 'trace_path', 'string', trace_file_path))
       except IOError, e:
         logging.error('Cannot open %s. %s' % (trace_file_path, e))
 
     model = model_module.TimelineModel(trace_result)
-    renderer_thread = model.GetRendererThreadFromTabId(tab.id)
-    meta_metrics = _TimelineBasedMetrics(
-        model, renderer_thread, _GetMetricFromMetricType)
+    meta_metrics = _TimelineBasedMetrics(model, _GetMetricFromMetricType)
     meta_metrics.AddResults(results)
 
   def CleanUpAfterPage(self, page, tab):
     if tab.browser.is_tracing_running:
       tab.browser.StopTracing()