Remove support for legacy wpr_server in Telemetry

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 os
 
-from telemetry.internal.util import wpr_server
 from telemetry.internal.util import webpagereplay_go_server
 from telemetry.internal.util import ts_proxy_server
 from telemetry.util import wpr_modes
 
 
 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._use_wpr_go = False
     self._archive_path = None
     self._make_javascript_deterministic = None
     self._forwarder = None
     self._wpr_server = None
     self._ts_proxy_server = None
     self._port_pair = None
     self._use_live_traffic = None
 
   def InitializeIfNeeded(self, use_live_traffic):
     """
@@ skipping 25 matching lines @@
   def host_ip(self):
     return self._platform_backend.forwarder_factory.host_ip
 
   @property
   def wpr_device_ports(self):
     try:
       return self._forwarder.port_pairs.remote_ports
     except AttributeError:
       return None
 
-  def Open(self, wpr_mode, extra_wpr_args, use_wpr_go=False):
+  def Open(self, wpr_mode, extra_wpr_args):
     """Configure and prepare target platform for network control.
 
     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.
 
     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.
     """
     assert not self.is_open, 'Network controller is already open'
     self._wpr_mode = wpr_mode
     self._extra_wpr_args = extra_wpr_args
-    self._use_wpr_go = use_wpr_go
 
   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._make_javascript_deterministic = None
     self._archive_path = None
     self._extra_wpr_args = None
-    self._use_wpr_go = False
     self._wpr_mode = None
 
   def StartReplay(self, archive_path, make_javascript_deterministic=False):
     """Start web page replay from a given replay archive.
 
     Starts as needed, and reuses if possible, the replay server on the host and
     a forwarder from the host to the target platform.
 
     Implementation details
     ----------------------
@@ skipping 49 matching lines @@
   def StopReplay(self):
     """Stop web page replay.
 
     Stops both the replay server and the forwarder if currently active.
     """
     self._StopReplayServer()
 
   def _StartReplayServer(self):
     """Start the replay server and return the started local_ports."""
     self._StopReplayServer()  # In case it was already running.
-    if self._use_wpr_go:
-      self._wpr_server = webpagereplay_go_server.ReplayServer(
-          self._archive_path,
-          self.host_ip,
-          http_port=0,
-          https_port=0,
-          replay_options=self._ReplayCommandLineArgs())
-    else:
-      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())
+    self._wpr_server = webpagereplay_go_server.ReplayServer(
+        self._archive_path,
+        self.host_ip,
+        http_port=0,
+        https_port=0,
+        replay_options=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."""
@@ skipping 20 matching lines @@
     self._ts_proxy_server.StartServer()
     return self._ts_proxy_server.port
 
   @property
   def forwarder(self):
     return self._forwarder
 
   @property
   def ts_proxy_server(self):
     return self._ts_proxy_server