[Telemetry] Move WPR life cycle from browser to platform

tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py

Index: tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py
diff --git a/tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py b/tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py
index ac43dc05e66b2c06622a0cfe151c42aa2e0866ee..e636c8178ffeb13a624eed48a30193f770008173 100644
--- a/tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py
+++ b/tools/telemetry/telemetry/internal/platform/network_controller_backend_unittest.py
@@ -29,22 +29,16 @@ class FakeForwarderFactory(object):
     return forwarders.Forwarder(port_pairs)
 
 
-class FakeBrowserBackend(object):
-  def __init__(self, http_ports, https_ports, dns_ports):
-    self.wpr_port_pairs = forwarders.PortPairs(
-      http=forwarders.PortPair(*http_ports),
-      https=forwarders.PortPair(*https_ports),
-      dns=forwarders.PortPair(*dns_ports) if dns_ports else None)
-
-
 class FakeReplayServer(object):
+  START_PORTS = NotImplemented
+
   def __init__(self, archive_path, host_ip, http_port, https_port, dns_port,
                replay_args):
     self.archive_path = archive_path
     self.host_ip = host_ip
-    self.http_port = http_port
-    self.https_port = https_port
-    self.dns_port = dns_port
+    self.http_port = self.START_PORTS.http if http_port == 0 else http_port
+    self.https_port = self.START_PORTS.https if https_port == 0 else https_port
+    self.dns_port = self.START_PORTS.dns if dns_port == 0 else dns_port
     self.replay_args = replay_args
     self.is_stopped = False
 
@@ -59,38 +53,23 @@ class FakeReplayServer(object):
 class TestNetworkControllerBackend(
     network_controller_backend.NetworkControllerBackend):
   """NetworkControllerBackend with a fake ReplayServer."""
+  REPLAY_SERVER_CLASS = FakeReplayServer
 
-  def __init__(self, platform_backend, fake_started_http_port,
-               fake_started_https_port, fake_started_dns_port):
-    super(TestNetworkControllerBackend, self).__init__(platform_backend)
-    self.fake_started_http_port = fake_started_http_port
-    self.fake_started_https_port = fake_started_https_port
-    self.fake_started_dns_port = fake_started_dns_port
-    self.fake_replay_server = None
-
-  def _ReplayServer(self, archive_path, host_ip, http_port, https_port,
-                    dns_port, replay_args):
-    http_port = http_port or self.fake_started_http_port
-    https_port = https_port or self.fake_started_https_port
-    dns_port = (None if dns_port is None else
-                (dns_port or self.fake_started_dns_port))
-    self.fake_replay_server = FakeReplayServer(
-        archive_path, host_ip, http_port, https_port, dns_port, replay_args)
-    return self.fake_replay_server
+  @property
+  def fake_replay_server(self):
+    return self._wpr_server
 
 
 class NetworkControllerBackendTest(unittest.TestCase):
 
   def setUp(self):
-    self.browser_backend = FakeBrowserBackend(
-        http_ports=(0, 0),
-        https_ports=(0, 0),
-        dns_ports=None)
+    FakeReplayServer.START_PORTS = forwarders.PortPairs(222, 444, None)
     self.network_controller_backend = TestNetworkControllerBackend(
-        FakePlatformBackend(),
-        fake_started_http_port=222,
-        fake_started_https_port=444,
-        fake_started_dns_port=None)
+        FakePlatformBackend())
+    self.network_controller_backend.SetWprPortPairs(
+        http=forwarders.PortPair(0, 0),
+        https=forwarders.PortPair(0, 0),
+        dns=None)
 
   def testSameArgsReuseServer(self):
     b = self.network_controller_backend
@@ -98,8 +77,8 @@ class NetworkControllerBackendTest(unittest.TestCase):
       archive_path = temp_file.name
 
       # Create Replay server.
-      b.SetReplayArgs(archive_path, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-      b.UpdateReplay(self.browser_backend)
+      b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+      b.StartReplay(archive_path)
 
       self.assertEqual(archive_path, b.fake_replay_server.archive_path)
       self.assertEqual('123.321.123.321', b.fake_replay_server.host_ip)
@@ -110,13 +89,13 @@ class NetworkControllerBackendTest(unittest.TestCase):
       self.assertEqual(444, b.wpr_https_device_port)
 
       # Reuse Replay server.
-      fake_replay_server = b.fake_replay_server
-      b.SetReplayArgs(archive_path, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-      b.UpdateReplay(self.browser_backend)
+      old_replay_server = b.fake_replay_server
+      b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+      b.StartReplay(archive_path)
 
-    self.assertIs(fake_replay_server, b.fake_replay_server)
+    self.assertIs(old_replay_server, b.fake_replay_server)
     b.StopReplay()
-    self.assertTrue(b.fake_replay_server.is_stopped)
+    self.assertTrue(old_replay_server.is_stopped)
 
   def testDifferentArgsUseDifferentServer(self):
     b = self.network_controller_backend
@@ -124,8 +103,8 @@ class NetworkControllerBackendTest(unittest.TestCase):
       archive_file = temp_file.name
 
       # Create Replay server.
-      b.SetReplayArgs(archive_file, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-      b.UpdateReplay(self.browser_backend)
+      b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+      b.StartReplay(archive_file)
 
       self.assertEqual(
         ['--some-arg', '--net=3g', '--inject_scripts='],
@@ -134,17 +113,15 @@ class NetworkControllerBackendTest(unittest.TestCase):
       self.assertEqual(444, b.wpr_https_device_port)
 
       # If Replay restarts, it uses these ports when passed "0" for ports.
-      b.fake_started_http_port = 212
-      b.fake_started_https_port = 323
-      b.fake_started_dns_port = None
+      FakeReplayServer.START_PORTS = forwarders.PortPairs(212, 323, None)
 
       # Create different Replay server (set netsim to None instead of 3g).
-      fake_replay_server = b.fake_replay_server
-      b.SetReplayArgs(archive_file, wpr_modes.WPR_REPLAY, None, ['--some-arg'])
-      b.UpdateReplay(self.browser_backend)
+      old_replay_server = b.fake_replay_server
+      b.SetReplayOptions(wpr_modes.WPR_REPLAY, None, ['--some-arg'])
+      b.StartReplay(archive_file)
 
-      self.assertIsNot(fake_replay_server, b.fake_replay_server)
-      self.assertTrue(fake_replay_server.is_stopped)
+      self.assertIsNot(old_replay_server, b.fake_replay_server)
+      self.assertTrue(old_replay_server.is_stopped)
       self.assertFalse(b.fake_replay_server.is_stopped)
 
     self.assertEqual(
@@ -152,112 +129,82 @@ class NetworkControllerBackendTest(unittest.TestCase):
       b.fake_replay_server.replay_args)
     self.assertEqual(212, b.wpr_http_device_port)
     self.assertEqual(323, b.wpr_https_device_port)
+    new_replay_server = b.fake_replay_server
     b.StopReplay()
-    self.assertTrue(b.fake_replay_server.is_stopped)
-
-  def testUpdateReplayWithoutArchivePathDoesNotStopReplay(self):
-    b = TestNetworkControllerBackend(
-        FakePlatformBackend(),
-        fake_started_http_port=222,
-        fake_started_https_port=444,
-        fake_started_dns_port=None)
+    self.assertTrue(new_replay_server.is_stopped)
+
+  def testStartReplayWithoutArchivePathDoesNotStopReplay(self):
+    b = self.network_controller_backend
     with tempfile.NamedTemporaryFile() as temp_file:
       archive_file = temp_file.name
       # Create Replay server.
-      b.SetReplayArgs(archive_file, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-      browser_backend = FakeBrowserBackend(
-        http_ports=(0, 0), https_ports=(0, 0), dns_ports=None)
-      b.UpdateReplay(browser_backend)
+      b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+      b.StartReplay(archive_file)
       self.assertFalse(b.fake_replay_server.is_stopped)
-    b.SetReplayArgs(None, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-    b.UpdateReplay()
+      old_replay_server = b.fake_replay_server
+    b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+    b.StartReplay(None)
+    self.assertIs(old_replay_server, b.fake_replay_server)
     self.assertFalse(b.fake_replay_server.is_stopped)
 
-  def testUpdateReplayWithoutArgsIsOkay(self):
+  def testStartReplayWithoutArgsIsOkay(self):
     b = self.network_controller_backend
-    b.UpdateReplay(self.browser_backend)  # does not raise
+    with tempfile.NamedTemporaryFile() as temp_file:
+      archive_file = temp_file.name
+      b.StartReplay(archive_file)  # does not raise
 
   def testBadArchivePathRaises(self):
     b = self.network_controller_backend
-    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_REPLAY, '3g', [])
+    b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
     with self.assertRaises(network_controller_backend.ArchiveDoesNotExistError):
-      b.UpdateReplay(self.browser_backend)
+      b.StartReplay('/tmp/nonexistant')
 
   def testBadArchivePathOnRecordIsOkay(self):
     """No ArchiveDoesNotExistError for record mode."""
     b = self.network_controller_backend
-    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_RECORD, '3g', [])
-    b.UpdateReplay(self.browser_backend)  # does not raise
+    b.SetReplayOptions(wpr_modes.WPR_RECORD, '3g', ['--some-arg'])
+    b.StartReplay('/tmp/nonexistant')  # does not raise
 
   def testModeOffDoesNotCreateReplayServer(self):
     b = self.network_controller_backend
-    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_OFF, '3g', [])
-    b.UpdateReplay(self.browser_backend)
+    b.SetReplayOptions(wpr_modes.WPR_OFF, '3g', ['--some-arg'])
+    b.StartReplay('/tmp/nonexistant')
     self.assertIsNone(b.fake_replay_server)
 
-  def testSameBrowserUsesSamePorts(self):
-    b = self.network_controller_backend
-    with tempfile.NamedTemporaryFile() as temp_file:
-      archive_path = temp_file.name
-
-      # Create Replay server.
-      b.SetReplayArgs(archive_path, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
-      b.UpdateReplay(self.browser_backend)
-
-      self.assertEqual(archive_path, b.fake_replay_server.archive_path)
-      self.assertEqual('123.321.123.321', b.fake_replay_server.host_ip)
-      self.assertEqual(
-        ['--some-arg', '--net=3g', '--inject_scripts='],
-        b.fake_replay_server.replay_args)
-      self.assertEqual(222, b.wpr_http_device_port)
-      self.assertEqual(444, b.wpr_https_device_port)
-
-      # If Replay restarts, it uses these ports when passed "0" for ports.
-      b.fake_started_http_port = 212
-      b.fake_started_https_port = 434
-      b.fake_started_dns_port = None
-
-      # Reuse Replay server.
-      fake_replay_server = b.fake_replay_server
-      b.SetReplayArgs(archive_path, wpr_modes.WPR_REPLAY, None, ['--NEW-ARG'])
-      b.UpdateReplay()  # no browser backend means use the previous one
-
-    # Even though WPR is restarted, it uses the same ports because
-    # the browser was configured to a particular port set.
-    self.assertIsNot(fake_replay_server, b.fake_replay_server)
-    self.assertEqual(222, b.wpr_http_device_port)
-    self.assertEqual(444, b.wpr_https_device_port)
-    b.StopReplay()
-    self.assertTrue(b.fake_replay_server.is_stopped)
-
-# pylint: disable=protected-access
-class ForwarderPortPairsTest(unittest.TestCase):
   def testZeroIsOkayForRemotePorts(self):
-    started_ports = (8080, 8443, None)
-    wpr_port_pairs = forwarders.PortPairs(
+    b = self.network_controller_backend
+    b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+    b.SetWprPortPairs(
         http=forwarders.PortPair(0, 0),
         https=forwarders.PortPair(0, 0),
         dns=None)
+    FakeReplayServer.START_PORTS = forwarders.PortPairs(8080, 8443, None)
     expected_port_pairs = forwarders.PortPairs(
-        http=forwarders.PortPair(8080, 0),
-        https=forwarders.PortPair(8443, 0),
+        http=forwarders.PortPair(8080, 8080),
+        https=forwarders.PortPair(8443, 8443),
         dns=None)
-    self.assertEqual(
-        expected_port_pairs,
-        network_controller_backend._ForwarderPortPairs(started_ports,
-                                                       wpr_port_pairs))
+    with tempfile.NamedTemporaryFile() as temp_file:
+      archive_file = temp_file.name
+      b.StartReplay(archive_file)
+      self.assertEqual(
+          expected_port_pairs,
+          b._forwarder.port_pairs)
 
   def testCombineStartedAndRemotePorts(self):
-    started_ports = (8888, 4343, 5353)
-    wpr_port_pairs = forwarders.PortPairs(
+    b = self.network_controller_backend
+    b.SetReplayOptions(wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+    b.SetWprPortPairs(
         http=forwarders.PortPair(0, 80),
         https=forwarders.PortPair(0, 443),
         dns=forwarders.PortPair(0, 53))
+    FakeReplayServer.START_PORTS = forwarders.PortPairs(8888, 4343, 5353)
     expected_port_pairs = forwarders.PortPairs(
         http=forwarders.PortPair(8888, 80),
         https=forwarders.PortPair(4343, 443),
         dns=forwarders.PortPair(5353, 53))
-    self.assertEqual(
-        expected_port_pairs,
-        network_controller_backend._ForwarderPortPairs(started_ports,
-                                                       wpr_port_pairs))
+    with tempfile.NamedTemporaryFile() as temp_file:
+      archive_file = temp_file.name
+      b.StartReplay(archive_file)
+      self.assertEqual(
+          expected_port_pairs,
+          b._forwarder.port_pairs)