sandwich: Implements network condition on WPR server and browser.

tools/android/loading/devtools_monitor.py

 # Copyright (c) 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.
 
 """Library handling DevTools websocket interaction.
 """
 
 import httplib
 import json
 import logging
 import os
 import sys
 
 file_dir = os.path.dirname(__file__)
 sys.path.append(os.path.join(file_dir, '..', '..', 'perf'))
 from chrome_telemetry_build import chromium_config
 sys.path.append(chromium_config.GetTelemetryDir())
 
 from telemetry.internal.backends.chrome_inspector import inspector_websocket
 from telemetry.internal.backends.chrome_inspector import websocket
 
 
+DEFAULT_TIMEOUT = 10 # seconds
+
+
 class DevToolsConnectionException(Exception):
   def __init__(self, message):
     super(DevToolsConnectionException, self).__init__(message)
     logging.warning("DevToolsConnectionException: " + message)
 
 
 # Taken from telemetry.internal.backends.chrome_inspector.tracing_backend.
 # TODO(mattcary): combine this with the above and export?
 class _StreamReader(object):
   def __init__(self, inspector, stream_handle):
@@ skipping 149 matching lines @@
   def SetUpMonitoring(self):
     for domain in self._domains_to_enable:
       self._ws.RegisterDomain(domain, self._OnDataReceived)
       if domain != self.TRACING_DOMAIN:
         self.SyncRequestNoResponse('%s.enable' % domain)
         # Tracing setup must be done by the tracing track to control filtering
         # and output.
     self._tearing_down_tracing = False
     self._set_up = True
 
-  def StartMonitoring(self):
+  def StartMonitoring(self, timeout=DEFAULT_TIMEOUT):
     """Starts monitoring.
 
     DevToolsConnection.SetUpMonitoring() has to be called first.
     """
     assert self._set_up, 'DevToolsConnection.SetUpMonitoring not called.'
-    self._Dispatch()
+    self._Dispatch(timeout=timeout)
     self._TearDownMonitoring()
 
   def StopMonitoring(self):
     """Stops the monitoring."""
     self._please_stop = True
 
-  def _Dispatch(self, kind='Monitoring', timeout=10):
+  def _Dispatch(self, kind='Monitoring',
+                timeout=DEFAULT_TIMEOUT):

[mattcary, 2016/02/19 15:40:17]

this timeout should be configured as part of the devtools connection. It gets
very unmaintainable passing all these configuration details as method
parameters.

[gabadie, 2016/02/22 10:05:00]

Agreed. But to me only few dispatch calls needed a longer timeout. Since this
custom timeout is significantly higher, it was making sens to not apply it to
every call and have a per call granularity.

To solve the maintainability, the TraceRecorder proposal was my solution,
because he could take car e of this. "Oh you are running on android with a 2g
emulated network on the browser side, let me change this timeout silently for
you so that you don't have to deal with it in your upper layers".

     self._please_stop = False
     while not self._please_stop:
       try:
         self._ws.DispatchNotifications(timeout=timeout)
       except websocket.WebSocketTimeoutException:
         break
     if not self._please_stop:
       logging.warning('%s stopped on a timeout.' % kind)
 
   def _TearDownMonitoring(self):
@@ skipping 109 matching lines @@
     """Returns a Track instance constructed from data dumped by
        Track.ToJsonDict().
 
     Args:
       json_data: (dict) Parsed from a JSON file using the json module.
 
     Returns:
       a Track instance.
     """
     pass