sandwich: Implements network condition on WPR server and browser.

tools/android/loading/chrome_setup.py

 # Copyright 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.
 
 """Handles Chrome's configuration."""
 
 import contextlib
 import json
 import shutil
 import subprocess
 import tempfile
 import time
 
 import devtools_monitor
 from options import OPTIONS
 
 
 # Copied from
 # WebKit/Source/devtools/front_end/network/NetworkConditionsSelector.js
-_NETWORK_CONDITIONS = {
-    'Offline': {
-        'download': 0 * 1024 / 8, 'upload': 0 * 1024 / 8, 'latency': 0},
+# Units:
+#   download/upload: byte/s
+#   latency: ms
+NETWORK_CONDITIONS = {
     'GPRS': {
         'download': 50 * 1024 / 8, 'upload': 20 * 1024 / 8, 'latency': 500},
     'Regular 2G': {
         'download': 250 * 1024 / 8, 'upload': 50 * 1024 / 8, 'latency': 300},
     'Good 2G': {
         'download': 450 * 1024 / 8, 'upload': 150 * 1024 / 8, 'latency': 150},
     'Regular 3G': {
         'download': 750 * 1024 / 8, 'upload': 250 * 1024 / 8, 'latency': 100},
     'Good 3G': {
         'download': 1.5 * 1024 * 1024 / 8, 'upload': 750 * 1024 / 8,
         'latency': 40},
     'Regular 4G': {
         'download': 4 * 1024 * 1024 / 8, 'upload': 3 * 1024 * 1024 / 8,
         'latency': 20},
     'DSL': {
         'download': 2 * 1024 * 1024 / 8, 'upload': 1 * 1024 * 1024 / 8,
         'latency': 5},
     'WiFi': {
         'download': 30 * 1024 * 1024 / 8, 'upload': 15 * 1024 * 1024 / 8,
         'latency': 2}
 }
 
 
+def BandwidthToString(bandwidth):
+  """Converts a bandwidth to string.
+
+  Args:
+    bandwidth: The bandwidth to convert in byte/s. Must be a multiple of 1024/8.
+
+  Returns:
+    A string compatible with wpr --{up,down} command line flags.
+  """
+  assert type(bandwidth) == int
+  assert bandwidth % (1024/8) == 0
+  bandwidth_kbps = (bandwidth * 8) / 1024
+  if bandwidth_kbps % 1024:
+    return '{}Kbit/s'.format(bandwidth_kbps)
+  return '{}Mbit/s'.format(bandwidth_kbps / 1024)
+
+
 @contextlib.contextmanager
 def DevToolsConnectionForLocalBinary(flags):
   """Returns a DevToolsConnection context manager for a local binary.
 
   Args:
     flags: ([str]) List of flags to pass to the browser.
 
   Returns:
     A DevToolsConnection context manager.
   """
@@ skipping 17 matching lines @@
 
 
 def SetUpEmulationAndReturnMetadata(connection, emulated_device_name,
                                     emulated_network_name):
   """Sets up the device and network emulation and returns the trace metadata.
 
   Args:
     connection: (DevToolsConnection)
     emulated_device_name: (str) Key in the dict returned by
                           _LoadEmulatedDevices().
-    emulated_network_name: (str) Key in _NETWORK_CONDITIONS.
+    emulated_network_name: (str) Key in NETWORK_CONDITIONS.
 
   Returns:
     A metadata dict {'deviceEmulation': params, 'networkEmulation': params}.
   """
   result = {'deviceEmulation': {}, 'networkEmulation': {}}
   if emulated_device_name:
     devices = _LoadEmulatedDevices(OPTIONS.devices_file)
     emulated_device = devices[emulated_device_name]
     emulation_params = _SetUpDeviceEmulationAndReturnMetadata(
         connection, emulated_device)
     result['deviceEmulation'] = emulation_params
   if emulated_network_name:
-    params = _NETWORK_CONDITIONS[emulated_network_name]
+    params = NETWORK_CONDITIONS[emulated_network_name]
     _SetUpNetworkEmulation(
         connection, params['latency'], params['download'], params['upload'])
     result['networkEmulation'] = params
   return result
 
 
 def _LoadEmulatedDevices(filename):
   """Loads a list of emulated devices from the DevTools JSON registry.
 
   Args:
@@ skipping 53 matching lines @@
     latency: (float) Latency in ms.
     download: (float) Download speed (Bytes / s).
     upload: (float) Upload speed (Bytes / s).
   """
   res = connection.SyncRequest('Network.canEmulateNetworkConditions')
   assert res['result'], 'Cannot set network emulation.'
   connection.SyncRequestNoResponse(
       'Network.emulateNetworkConditions',
       {'offline': False, 'latency': latency, 'downloadThroughput': download,
        'uploadThroughput': upload})