Remove StartAsyncDispatchNotifications from inspector_websocket

tools/telemetry/telemetry/core/backends/chrome/tracing_backend.py

 # Copyright 2013 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 re
 
 from telemetry.core.backends.chrome import inspector_websocket
 
 
@@ skipping 10 matching lines @@
                             "benchmark,"
                             "webkit.console,"
                             "blink.console,"
                             "trace_event_overhead")
 
 
 class TracingUnsupportedException(Exception):
   pass
 
 
+class TracingTimeoutException(Exception):
+  pass
+
+
 class CategoryFilter(object):
   def __init__(self, filter_string):
     self.excluded = set()
     self.included = set()
     self.disabled = set()
     self.synthetic_delays = set()
     self.contains_wildcards = False
 
     if not filter_string:
       return
@@ skipping 62 matching lines @@
   def __init__(self, devtools_port):
     self._inspector_websocket = inspector_websocket.InspectorWebsocket(
         self._NotificationHandler,
         self._ErrorHandler)
 
     self._inspector_websocket.Connect(
         'ws://127.0.0.1:%i/devtools/browser' % devtools_port)
     self._category_filter = None
     self._nesting = 0
     self._tracing_data = []
+    self._is_tracing_running = False
 
   @property
   def is_tracing_running(self):
-    return self._inspector_websocket.is_dispatching_async_notifications
+    return self._is_tracing_running
 
   def StartTracing(self, custom_categories=None, timeout=10):
     """ Starts tracing on the first nested call and returns True. Returns False
         and does nothing on subsequent nested calls.
     """
     self._nesting += 1
     if self.is_tracing_running:
       new_category_filter = CategoryFilter(custom_categories)
       is_subset = new_category_filter.IsSubset(self._category_filter)
       assert(is_subset != False)
       if is_subset == None:
         logging.warning('Cannot determine if category filter of nested ' +
                         'StartTracing call is subset of current filter.')
       return False
     self._CheckNotificationSupported()
     req = {'method': 'Tracing.start'}
     self._category_filter = CategoryFilter(custom_categories)
     if custom_categories:
       req['params'] = {'categories': custom_categories}
     self._inspector_websocket.SyncRequest(req, timeout)
-    # Tracing.start will send asynchronous notifications containing trace
-    # data, until Tracing.end is called.
-    self._inspector_websocket.StartAsyncDispatchNotifications()
+    self._is_tracing_running = True
     return True
 
-  def StopTracing(self):
+  def StopTracing(self, timeout=30):
     """ Stops tracing on the innermost (!) nested call, because we cannot get
         results otherwise. Resets _tracing_data on the outermost nested call.
         Returns the result of the trace, as TracingTimelineData object.
     """
     self._nesting -= 1
     assert self._nesting >= 0
     if self.is_tracing_running:
       req = {'method': 'Tracing.end'}
       self._inspector_websocket.SendAndIgnoreResponse(req)
-      self._inspector_websocket.StopAsyncDispatchNotifications()
+      # After Tracing.end, chrome browser will send asynchronous notifications
+      # containing trace data. This is until Tracing.tracingComplete is sent,
+      # which means there is no trace buffers pending flush.
+      try:
+        self._inspector_websocket.DispatchNotificationsUntilDone(timeout)
+      except \
+          inspector_websocket.DispatchNotificationsUntilDoneTimeoutException \
+          as err:
+        raise TracingTimeoutException(
+            'Trace data was not fully received due to timeout after %s '
+            'seconds. If the trace data is big, you may want to increase the '
+            'time out amount.' % err.elapsed_time)

[chrishenry, 2014/07/11 18:27:59]

nit: timeout

+      self._is_tracing_running = False
     if self._nesting == 0:
       self._category_filter = None
       return self._GetTraceResultAndReset()
     else:
       return self._GetTraceResult()
 
   def _GetTraceResult(self):
     assert not self.is_tracing_running
     return self._tracing_data
 
@@ skipping 25 matching lines @@
 
   def _CheckNotificationSupported(self):
     """Ensures we're running against a compatible version of chrome."""
     req = {'method': 'Tracing.hasCompleted'}
     res = self._inspector_websocket.SyncRequest(req)
     if res.get('response'):
       raise TracingUnsupportedException(
           'Tracing not supported for this browser')
     elif 'error' in res:
       return