Add responsiveness_metric for timeline_based_measurement

tools/telemetry/telemetry/web_perf/timeline_interaction_record.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 re
 
 from telemetry import decorators
 import telemetry.core.timeline.bounds as timeline_bounds
 
 
 IS_SMOOTH = 'is_smooth'
-IS_LOADING_RESOURCES = 'is_loading_resources'
+IS_RESPONSIVE = 'is_responsive'
 
 FLAGS = [
     IS_SMOOTH,
-    IS_LOADING_RESOURCES
+    IS_RESPONSIVE
 ]
 
 
 class ThreadTimeRangeOverlappedException(Exception):
   """Exception that can be thrown when computing overlapped thread time range
   with other events.
   """
 
+class NoThreadTimeDataException(ThreadTimeRangeOverlappedException):
+  """Exception that can be thrown if there is not sufficient thread time data
+  to compute the overlapped thread time range."""
 
 def IsTimelineInteractionRecord(event_name):
   return event_name.startswith('Interaction.')
 
 
 class TimelineInteractionRecord(object):
   """Represents an interaction that took place during a timeline recording.
 
   As a page runs, typically a number of different (simulated) user interactions
   take place. For instance, a user might click a button in a mail app causing a
@@ skipping 10 matching lines @@
   Determining these things is hard to do, simply by observing the state given to
   a page from javascript. There are hints, for instance if network requests are
   sent, or if a CSS animation is pending. But this is by no means a complete
   story.
 
   Instead, we expect pages to mark up the timeline what they are doing, with
   logical names, and flags indicating the semantics of that interaction. This
   is currently done by pushing markers into the console.time/timeEnd API: this
   for instance can be issued in JS:
 
-     var str = 'Interaction.SendEmail/is_smooth,is_loading_resources';
+     var str = 'Interaction.SendEmail/is_smooth,is_responsive';
      console.time(str);
      setTimeout(function() {
        console.timeEnd(str);
      }, 1000);
 
   When run with perf.measurements.timeline_based_measurement running, this will
   then cause a TimelineInteractionRecord to be created for this range and both
   smoothness and network metrics to be reported for the marked up 1000ms
   time-range.
 
   """
 
   def __init__(self, logical_name, start, end, async_event=None):
     assert logical_name
     self.logical_name = logical_name
     self.start = start
     self.end = end
     self.is_smooth = False
-    self.is_loading_resources = False
+    self.is_responsive = False
     self._async_event = async_event
 
   # TODO(nednguyen): After crbug.com/367175 is marked fixed, we should be able
   # to get rid of perf.measurements.smooth_gesture_util and make this the only
   # constructor method for TimelineInteractionRecord.
   @staticmethod
   def FromAsyncEvent(async_event):
     """Construct an timeline_interaction_record from an async event.
     Args:
       async_event: An instance of
         telemetry.core.timeline.async_slices.AsyncSlice
     """
+    assert async_event.start_thread == async_event.end_thread, (
+        'Start thread of this record\'s async event is not the same as its '
+        'end thread')
     m = re.match('Interaction\.(.+)\/(.+)', async_event.name)
     if m:
       logical_name = m.group(1)
       if m.group(1) != '':
         flags = m.group(2).split(',')
       else:
         flags = []
     else:
       m = re.match('Interaction\.(.+)', async_event.name)
       assert m
       logical_name = m.group(1)
       flags = []
 
     record = TimelineInteractionRecord(logical_name, async_event.start,
                                        async_event.end, async_event)
     for f in flags:
       if not f in FLAGS:
         raise Exception(
             'Unrecognized flag in timeline Interaction record: %s' % f)
     record.is_smooth = IS_SMOOTH in flags
-    record.is_loading_resources = IS_LOADING_RESOURCES in flags
+    record.is_responsive = IS_RESPONSIVE in flags
     return record
 
   def GetResultNameFor(self, result_name):
     return '%s-%s' % (self.logical_name, result_name)
 
   @decorators.Cache
   def GetBounds(self):
     bounds = timeline_bounds.Bounds()
     bounds.AddValue(self.start)
     bounds.AddValue(self.end)
@@ skipping 44 matching lines @@
       thread, and thus can't be used to compute the overlapped thread duration.
       Hence, we use a heuristic to compute the overlap (see
       _GetOverlappedThreadTimeForSliceInDifferentThread for more details)
 
     Args:
       timeline_slice: An instance of telemetry.core.timeline.slice.Slice
     """
     if not self._async_event:
       raise ThreadTimeRangeOverlappedException(
           'This record was not constructed from async event')
-    if self._async_event.start_thread != self._async_event.end_thread:
-      raise ThreadTimeRangeOverlappedException(
-          'Start thread of this record\'s async event is not the same as its '
-          'end thread')
     if not self._async_event.has_thread_timestamps:
-      raise ThreadTimeRangeOverlappedException(
+      raise NoThreadTimeDataException(
           'This record\'s async_event does not contain thread time data. '
           'Event data: %s' % repr(self._async_event))
     if not timeline_slice.has_thread_timestamps:
-      raise ThreadTimeRangeOverlappedException(
+      raise NoThreadTimeDataException(
           'slice does not contain thread time data')
 
     if timeline_slice.parent_thread == self._async_event.start_thread:
       return self._GetOverlappedThreadTimeForSliceInSameThread(
           timeline_slice)
     else:
       return self._GetOverlappedThreadTimeForSliceInDifferentThread(
           timeline_slice)
 
   def _GetOverlappedThreadTimeForSliceInSameThread(self, timeline_slice):
@@ skipping 11 matching lines @@
         timeline_slice.start, timeline_slice.end,
         self.start, self.end)
     if timeline_slice.duration == 0 or self._async_event.duration == 0:
       return 0
     timeline_slice_scheduled_ratio = (
         timeline_slice.thread_duration / float(timeline_slice.duration))
     record_scheduled_ratio = (
         self._async_event.thread_duration / float(self._async_event.duration))
     return (overlapped_walltime_duration * timeline_slice_scheduled_ratio *
             record_scheduled_ratio)