Revert "[telemetry] Wire TsProxy through telemetry's network stack."

telemetry/telemetry/internal/platform/network_controller_backend.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
 import shutil
 import tempfile
 
+from telemetry.internal import forwarders
 from telemetry.internal.util import wpr_server
-from telemetry.internal.util import ts_proxy_server
 from telemetry.util import wpr_modes
 
 import certutils
 import platformsettings
 
 
 class ArchiveDoesNotExistError(Exception):
   """Raised when the archive path does not exist for replay mode."""
   pass
 
 
 class ReplayAndBrowserPortsError(Exception):
   """Raised an existing browser would get different remote replay ports."""
   pass
 
 
 class NetworkControllerBackend(object):
   """Control network settings and servers to simulate the Web.
 
   Network changes include forwarding device ports to host platform ports.
   Web Page Replay is used to record and replay HTTP/HTTPS responses.
   """
 
   def __init__(self, platform_backend):
     self._platform_backend = platform_backend
     self._wpr_mode = None
     self._extra_wpr_args = None
+    self._wpr_port_pairs = None
     self._archive_path = None
     self._make_javascript_deterministic = None
     self._forwarder = None
     self._wpr_ca_cert_path = None
     self._wpr_server = None
-    self._ts_proxy_server = None
-    self._port_pair = None
-
-  def InitializeIfNeeded(self):
-    """
-    This may, e.g., install test certificates and perform any needed setup
-    on the target platform.
-
-    After network interactions are over, clients should call the Close method.
-    """
-    assert bool(self._ts_proxy_server) == bool(self._forwarder)
-    if self._ts_proxy_server:
-      return
-    local_port = self._StartTsProxyServer()
-    self._forwarder = self._platform_backend.forwarder_factory.Create(
-        self._platform_backend.GetPortPairForForwarding(local_port))
 
   @property
   def is_open(self):
     return self._wpr_mode is not None
 
   @property
   def is_replay_active(self):
     return self._forwarder is not None
 
   @property
@@ skipping 18 matching lines @@
     on the target platform.
 
     After network interactions are over, clients should call the Close method.
 
     Args:
       wpr_mode: a mode for web page replay; available modes are
           wpr_modes.WPR_OFF, wpr_modes.APPEND, wpr_modes.WPR_REPLAY, or
           wpr_modes.WPR_RECORD.
       extra_wpr_args: an list of extra arguments for web page replay.
     """
-    self.InitializeIfNeeded()
     assert not self.is_open, 'Network controller is already open'
     self._wpr_mode = wpr_mode
     self._extra_wpr_args = extra_wpr_args
+    self._wpr_port_pairs = self._platform_backend.GetWprPortPairs()
     self._InstallTestCa()
 
   def Close(self):
     """Undo changes in the target platform used for network control.
 
     Implicitly stops replay if currently active.
     """
     self.StopReplay()
-    self._StopForwarder()
-    self._StopTsProxyServer()
     self._RemoveTestCa()
     self._make_javascript_deterministic = None
     self._archive_path = None
+    self._wpr_port_pairs = None
     self._extra_wpr_args = None
     self._wpr_mode = None
 
   def _InstallTestCa(self):
     if not self._platform_backend.supports_test_ca:
       return
     assert not self.is_test_ca_installed, 'Test CA is already installed'
     if certutils.openssl_import_error:
       logging.warning(
           'The OpenSSL module is unavailable. '
@@ skipping 73 matching lines @@
       raise ArchiveDoesNotExistError(
           'Archive path does not exist: %s' % archive_path)
     if (self._wpr_server is not None and
         self._archive_path == archive_path and
         self._make_javascript_deterministic == make_javascript_deterministic):
       return  # We may reuse the existing replay server.
 
     self._archive_path = archive_path
     self._make_javascript_deterministic = make_javascript_deterministic
     local_ports = self._StartReplayServer()
-    self._ts_proxy_server.UpdateOutboundPorts(
-        http_port=local_ports.http, https_port=local_ports.https)
-
-  def _StopForwarder(self):
-    if self._forwarder:
-      self._forwarder.Close()
-      self._forwarder = None
+    self._StartForwarder(local_ports)
 
   def StopReplay(self):
     """Stop web page replay.
 
     Stops both the replay server and the forwarder if currently active.
     """
+    if self._forwarder:
+      self._forwarder.Close()
+      self._forwarder = None
     self._StopReplayServer()
 
   def _StartReplayServer(self):
     """Start the replay server and return the started local_ports."""
     self._StopReplayServer()  # In case it was already running.
+    local_ports = self._wpr_port_pairs.local_ports
     self._wpr_server = wpr_server.ReplayServer(
         self._archive_path,
         self.host_ip,
-        http_port=0,
-        https_port=0,
-        dns_port=None,
-        replay_options=self._ReplayCommandLineArgs())
+        local_ports.http,
+        local_ports.https,
+        local_ports.dns,
+        self._ReplayCommandLineArgs())
     return self._wpr_server.StartServer()
 
   def _StopReplayServer(self):
     """Stop the replay server only."""
     if self._wpr_server:
       self._wpr_server.StopServer()
       self._wpr_server = None
 
-  def _StopTsProxyServer(self):
-    """Stop the replay server only."""
-    if self._ts_proxy_server:
-      self._ts_proxy_server.StopServer()
-      self._ts_proxy_server = None
-
   def _ReplayCommandLineArgs(self):
     wpr_args = list(self._extra_wpr_args)
     if self._wpr_mode == wpr_modes.WPR_APPEND:
       wpr_args.append('--append')
     elif self._wpr_mode == wpr_modes.WPR_RECORD:
       wpr_args.append('--record')
     if not self._make_javascript_deterministic:
       wpr_args.append('--inject_scripts=')
     if self._wpr_ca_cert_path:
       wpr_args.extend([
           '--should_generate_certs',
           '--https_root_ca_cert_path=%s' % self._wpr_ca_cert_path])
     return wpr_args
 
-  def _StartTsProxyServer(self):
-    assert not self._ts_proxy_server, 'ts_proxy_server is already started'
-    self._ts_proxy_server = ts_proxy_server.TsProxyServer(host_ip=self.host_ip)
-    self._ts_proxy_server.StartServer()
-    return self._ts_proxy_server.port
-
-  @property
-  def forwarder(self):
-    return self._forwarder
+  def _StartForwarder(self, local_ports):
+    """Start a forwarder from local_ports to the set WPR remote_ports."""
+    if self._forwarder is not None:
+      if local_ports == self._forwarder.port_pairs.local_ports:
+        return  # Safe to reuse existing forwarder.
+      self._forwarder.Close()
+    self._forwarder = self._platform_backend.forwarder_factory.Create(
+        forwarders.PortPairs.Zip(local_ports,
+                                 self._wpr_port_pairs.remote_ports))
+    # Override port pairts with values after defaults have been resolved;
+    # we should use the same set of ports when restarting replay.
+    self._wpr_port_pairs = self._forwarder.port_pairs