Telemetry: Step 1 of moving Web Page Replay to the platform.

In this step, we move WPR down to platform without making
any changes to the lifecycle nor where the input comes from.
API and lifecycle cleanup to follow in a follow up patch.

BUG=404771

Review URL: https://codereview.chromium.org/656303003

Cr-Commit-Position: refs/heads/master@{#301578}

tools/telemetry/telemetry/core/backends/chrome/android_browser_finder.py

@@ -116,13 +116,9 @@ class PossibleAndroidBrowser(possible_browser.PossibleBrowser):
         extensions_to_load=self.finder_options.extensions_to_load,
         target_arch=self.finder_options.target_arch,
         android_platform_backend=self._platform_backend)
-    b = browser.Browser(backend,
-                        self._platform_backend,
-                        self._archive_path,
-                        self._append_to_existing_wpr,
-                        self._make_javascript_deterministic,
-                        self._credentials_path)
-    return b
+    return browser.Browser(
+        backend, self._platform_backend, self._credentials_path)
+
 
   def SupportsOptions(self, finder_options):
     if len(finder_options.extensions_to_load) != 0:

tools/telemetry/telemetry/core/backends/chrome/cros_browser_finder.py

@@ -51,16 +51,9 @@ class PossibleCrOSBrowser(possible_browser.PossibleBrowser):
       return cros_browser_with_oobe.CrOSBrowserWithOOBE(
           backend,
           self._platform_backend,
-          self._archive_path,
-          self._append_to_existing_wpr,
-          self._make_javascript_deterministic,
           self._credentials_path)
-    return browser.Browser(backend,
-                           self._platform_backend,
-                           self._archive_path,
-                           self._append_to_existing_wpr,
-                           self._make_javascript_deterministic,
-                           self._credentials_path)
+    return browser.Browser(
+        backend, self._platform_backend, self._credentials_path)
 
   def SupportsOptions(self, finder_options):
     if (len(finder_options.extensions_to_load) != 0) and self._is_guest:

tools/telemetry/telemetry/core/backends/chrome/cros_browser_with_oobe.py

@@ -8,16 +8,10 @@ from telemetry.core.backends.chrome import cros_browser_backend
 
 class CrOSBrowserWithOOBE(browser.Browser):
   """Cros-specific browser."""
-  def __init__(self, backend, platform_backend, archive_path,
-               append_to_existing_wpr, make_javascript_deterministic,
-               credentials_path):
+  def __init__(self, backend, platform_backend, credentials_path):
     assert isinstance(backend, cros_browser_backend.CrOSBrowserBackend)
-    super(CrOSBrowserWithOOBE, self).__init__(backend,
-                                              platform_backend,
-                                              archive_path,
-                                              append_to_existing_wpr,
-                                              make_javascript_deterministic,
-                                              credentials_path)
+    super(CrOSBrowserWithOOBE, self).__init__(
+        backend, platform_backend, credentials_path)
 
   @property
   def oobe(self):

tools/telemetry/telemetry/core/backends/chrome/desktop_browser_finder.py

@@ -60,12 +60,8 @@ class PossibleDesktopBrowser(possible_browser.PossibleBrowser):
         self._flash_path, self._is_content_shell, self._browser_directory,
         output_profile_path=self.finder_options.output_profile_path,
         extensions_to_load=self.finder_options.extensions_to_load)
-    return browser.Browser(backend,
-                           self._platform_backend,
-                           self._archive_path,
-                           self._append_to_existing_wpr,
-                           self._make_javascript_deterministic,
-                           self._credentials_path)
+    return browser.Browser(
+        backend, self._platform_backend, self._credentials_path)
 
   def SupportsOptions(self, finder_options):
     if (len(finder_options.extensions_to_load) != 0) and self._is_content_shell:

tools/telemetry/telemetry/core/backends/chrome/ios_browser_finder.py

@@ -35,12 +35,8 @@ class PossibleIOSBrowser(possible_browser.PossibleBrowser):
   def Create(self):
     backend = ios_browser_backend.IosBrowserBackend(
         self.finder_options.browser_options)
-    return browser.Browser(backend,
-                           self._platform_backend,
-                           self._archive_path,
-                           self._append_to_existing_wpr,
-                           self._make_javascript_deterministic,
-                           self._credentials_path)
+    return browser.Browser(
+        backend, self._platform_backend, self._credentials_path)
 
   def SupportsOptions(self, finder_options):
     #TODO(baxley): Implement me.

tools/telemetry/telemetry/core/browser.py

@@ -12,8 +12,6 @@ from telemetry.core import extension_dict
 from telemetry.core import local_server
 from telemetry.core import memory_cache_http_server
 from telemetry.core import tab_list
-from telemetry.core import wpr_modes
-from telemetry.core import wpr_server
 from telemetry.core.backends import browser_backend
 
 
@@ -28,24 +26,17 @@ class Browser(app.App):
     with browser_to_create.Create() as browser:
       ... do all your operations on browser here
   """
-  def __init__(self, backend, platform_backend, archive_path,
-               append_to_existing_wpr, make_javascript_deterministic,
-               credentials_path):
+  def __init__(self, backend, platform_backend, credentials_path):
     super(Browser, self).__init__(app_backend=backend,
                                   platform_backend=platform_backend)
     self._browser_backend = backend
     self._platform_backend = platform_backend
-    self._wpr_server = None
     self._local_server_controller = local_server.LocalServerController(backend)
     self._tabs = tab_list.TabList(backend.tab_list_backend)
     self.credentials = browser_credentials.BrowserCredentials()
     self.credentials.credentials_path = credentials_path
     self._platform_backend.DidCreateBrowser(self, self._browser_backend)
 
-    self.SetReplayArchivePath(archive_path,
-                              append_to_existing_wpr,
-                              make_javascript_deterministic)
-
     browser_options = self._browser_backend.browser_options
     self.platform.FlushDnsCache()
     if browser_options.clear_sytem_cache_for_browser_and_profile_on_start:
@@ -258,10 +249,6 @@ class Browser(app.App):
     if self._browser_backend.IsBrowserRunning():
       self._platform_backend.WillCloseBrowser(self, self._browser_backend)
 
-    if self._wpr_server:
-      self._wpr_server.Close()
-      self._wpr_server = None
-
     self._local_server_controller.Close()
     self._browser_backend.Close()
     self.credentials = None
@@ -312,29 +299,6 @@ class Browser(app.App):
     """Returns the currently running local servers."""
     return self._local_server_controller.local_servers
 
-  def SetReplayArchivePath(self, archive_path, append_to_existing_wpr=False,
-                           make_javascript_deterministic=True):
-    if self._wpr_server:
-      self._wpr_server.Close()
-      self._wpr_server = None
-
-    if not archive_path:
-      return None
-
-    wpr_mode = self._browser_backend.wpr_mode
-    if wpr_mode == wpr_modes.WPR_OFF:
-      return
-    if wpr_mode == wpr_modes.WPR_RECORD and append_to_existing_wpr:
-      wpr_mode = wpr_modes.WPR_APPEND
-    if wpr_mode == wpr_modes.WPR_REPLAY:
-      assert os.path.isfile(archive_path)
-
-    self._wpr_server = wpr_server.ReplayServer(
-        self._browser_backend,
-        archive_path,
-        wpr_mode,
-        make_javascript_deterministic)
-
   def GetStandardOutput(self):
     return self._browser_backend.GetStandardOutput()
 

tools/telemetry/telemetry/core/platform/__init__.py

@@ -8,6 +8,7 @@ import sys
 
 from telemetry.core import discover
 from telemetry.core import util
+from telemetry.core.platform import network_controller
 from telemetry.core.platform import platform_backend as platform_backend_module
 from telemetry.core.platform import profiling_controller
 from telemetry.core.platform import tracing_controller
@@ -89,11 +90,18 @@ class Platform(object):
   def __init__(self, platform_backend):
     self._platform_backend = platform_backend
     self._platform_backend.SetPlatform(self)
+    self._network_controller = network_controller.NetworkController(
+        self._platform_backend.network_controller_backend)
     self._tracing_controller = tracing_controller.TracingController(
         self._platform_backend.tracing_controller_backend)
     self._profiling_controller = profiling_controller.ProfilingController(
         self._platform_backend.profiling_controller_backend)
 
+  @property
+  def network_controller(self):
+    """Control network settings and servers to simulate the Web."""
+    return self._network_controller
+
   @property
   def tracing_controller(self):
     return self._tracing_controller

tools/telemetry/telemetry/core/platform/network_controller.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.
+
+class NetworkController(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, network_controller_backend):
+    self._network_controller_backend = network_controller_backend
+
+  def SetReplayArgs(self, archive_path, wpr_mode, netsim, extra_wpr_args,
+                    make_javascript_deterministic=False):
+    """Save the arguments needed for replay."""
+    self._network_controller_backend.SetReplayArgs(
+        archive_path, wpr_mode, netsim, extra_wpr_args,
+        make_javascript_deterministic)
+
+  def UpdateReplayForExistingBrowser(self):
+    """Restart replay if needed for an existing browser.
+
+    TODO(slamm): Drop this method when the browser_backend dependencies are
+    moved to the platform. https://crbug.com/423962
+    """
+    self._network_controller_backend.UpdateReplay()

tools/telemetry/telemetry/core/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.core import wpr_modes
+from telemetry.core import wpr_server
+
+
+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._browser_backend = None
+    self._wpr_server = None
+    self._active_replay_args = {}
+    self._pending_replay_args = {}
+
+  def SetReplayArgs(self, archive_path, wpr_mode, netsim, extra_wpr_args,
+                    make_javascript_deterministic=False):
+    """Save the arguments needed for replay.
+
+    To make the settings effective, this call must be followed by a call
+    to UpdateReplay.
+
+    Args:
+      archive_path: a path to a specific WPR archive.
+      wpr_mode: one of wpr_modes.WPR_OFF, wpr_modes.WPR_APPEND,
+          wpr_modes.WPR_REPLAY, or wpr_modes.WPR_RECORD.
+      netsim: a net_config string ('dialup', '3g', 'dsl', 'cable', or 'fios').
+      extra_wpr_args: a list of addtional replay args (or an empty list).
+      make_javascript_deterministic: True if replay should inject a script
+          to make JavaScript behave deterministically (e.g., override Date()).
+    """
+    self._pending_replay_args = dict(
+        archive_path=archive_path,
+        wpr_mode=wpr_mode,
+        netsim=netsim,
+        extra_wpr_args=extra_wpr_args,
+        make_javascript_deterministic=make_javascript_deterministic)
+    # TODO(slamm): Update replay here when the browser_backend dependencies
+    # are moved to the platform. https://crbug.com/423962
+    # |self._pending_replay_args| can be removed at that time.
+
+  def UpdateReplay(self, browser_backend=None):
+    """Start or reuse Web Page Replay.
+
+    UpdateReplay must be called after every call to SetReplayArgs.
+
+    TODO(slamm): Update replay in SetReplayArgs once the browser_backend
+        dependencies move to platform. https://crbug.com/423962
+        browser_backend properties used:
+          - Input: forwarder_factory, wpr_port_pairs, wpr_ca_cert_path
+          - Output: wpr_port_pairs (browser uses for --testing-fixed-* flags).
+    Args:
+      browser_backend: instance of telemetry.core.backends.browser_backend
+    """
+    if not self._pending_replay_args:
+      # In some cases (e.g., unit tests), the browser is used without replay.
+      return
+    if self._pending_replay_args == self._active_replay_args:
+      return
+
+    self.StopReplay()
+
+    pending_archive_path = self._pending_replay_args['archive_path']
+    pending_wpr_mode = self._pending_replay_args['wpr_mode']
+    if not pending_archive_path or pending_wpr_mode == wpr_modes.WPR_OFF:
+      return
+    if (pending_wpr_mode == wpr_modes.WPR_REPLAY and
+        not os.path.exists(pending_archive_path)):
+      raise ArchiveDoesNotExistError(
+          'Archive path does not exist: %s' % pending_archive_path)
+    if browser_backend:
+      self._browser_backend = browser_backend
+    else:
+      # If no browser_backend, then this is an update for an existing wpr.
+      assert self._browser_backend
+    self._wpr_server = self._ReplayServer(
+        self._browser_backend, self._pending_replay_args)
+    self._active_replay_args = self._pending_replay_args
+    self._pending_replay_args = None
+
+  def _ReplayServer(self, browser_backend, replay_args):
+    return wpr_server.ReplayServer(browser_backend, **replay_args)
+
+  def StopReplay(self):
+    if self._wpr_server:
+      self._wpr_server.Close()
+      self._wpr_server = None
+      self._active_replay_args = {}

tools/telemetry/telemetry/core/platform/network_controller_backend_unittest.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 tempfile
+import unittest
+
+from telemetry.core import wpr_modes
+from telemetry.core.platform import network_controller_backend
+
+
+class FakePlatformBackend(object):
+  pass
+
+
+class FakeBrowserBackend(object):
+  pass
+
+
+class FakeReplayServer(object):
+  def __init__(self, browser_backend, **replay_args):
+    self.browser_backend = browser_backend
+    self.replay_args = replay_args
+    self.is_closed = False
+
+  def Close(self):
+    assert not self.is_closed
+    self.is_closed = True
+
+
+class TestNetworkControllerBackend(
+    network_controller_backend.NetworkControllerBackend):
+  """NetworkControllerBackend with a fake ReplayServer."""
+
+  def __init__(self, platform_backend):
+    super(TestNetworkControllerBackend, self).__init__(platform_backend)
+    self.fake_replay_server = None
+
+  def _ReplayServer(self, browser_backend, replay_args):
+    self.fake_replay_server = FakeReplayServer(browser_backend, **replay_args)
+    return self.fake_replay_server
+
+
+class NetworkControllerBackendTest(unittest.TestCase):
+
+  def testSameArgsReusesServer(self):
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    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()
+      b.UpdateReplay(browser_backend)
+      self.assertIs(browser_backend, b.fake_replay_server.browser_backend)
+      expected_replay_args = dict(
+          archive_path=archive_file,
+          wpr_mode=wpr_modes.WPR_REPLAY,
+          netsim='3g',
+          extra_wpr_args=['--some-arg'],
+          make_javascript_deterministic=False)
+      self.assertEqual(expected_replay_args, b.fake_replay_server.replay_args)
+
+      # Reuse Replay server.
+      fake_replay_server = b.fake_replay_server
+      b.SetReplayArgs(archive_file, wpr_modes.WPR_REPLAY, '3g', ['--some-arg'])
+      b.UpdateReplay(browser_backend)
+
+    self.assertIs(fake_replay_server, b.fake_replay_server)
+    b.StopReplay()
+    self.assertTrue(b.fake_replay_server.is_closed)
+
+  def testDifferentArgsUsesDifferentServer(self):
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    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()
+      b.UpdateReplay(browser_backend)
+      self.assertIs(browser_backend, b.fake_replay_server.browser_backend)
+      expected_replay_args = dict(
+          archive_path=archive_file,
+          wpr_mode=wpr_modes.WPR_REPLAY,
+          netsim='3g',
+          extra_wpr_args=['--some-arg'],
+          make_javascript_deterministic=False)
+      self.assertEqual(expected_replay_args, b.fake_replay_server.replay_args)
+      fake_replay_server = b.fake_replay_server
+
+      # Create different Replay server.
+      # Set netsim to None instead of '3g'.
+      b.SetReplayArgs(archive_file, wpr_modes.WPR_REPLAY, None, ['--some-arg'])
+      b.UpdateReplay(browser_backend)
+
+      self.assertIsNot(fake_replay_server, b.fake_replay_server)
+      self.assertTrue(fake_replay_server.is_closed)
+      self.assertFalse(b.fake_replay_server.is_closed)
+      different_replay_args = dict(
+          archive_path=archive_file,
+          wpr_mode=wpr_modes.WPR_REPLAY,
+          netsim=None,  # first call used '3g'
+          extra_wpr_args=['--some-arg'],
+          make_javascript_deterministic=False)
+
+    self.assertEqual(different_replay_args, b.fake_replay_server.replay_args)
+    b.StopReplay()
+    self.assertTrue(b.fake_replay_server.is_closed)
+
+  def testUpdateReplayWithoutArgsIsOkay(self):
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    b.UpdateReplay(FakeBrowserBackend())  # does not raise
+
+  def testBadArchivePathRaises(self):
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_REPLAY, '3g', [])
+    with self.assertRaises(network_controller_backend.ArchiveDoesNotExistError):
+      b.UpdateReplay(FakeBrowserBackend())
+
+  def testBadArchivePathOnRecordIsOkay(self):
+    """No ArchiveDoesNotExistError for record mode."""
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_RECORD, '3g', [])
+    b.UpdateReplay(FakeBrowserBackend())  # does not raise
+
+  def testModeOffDoesNotCreateReplayServer(self):
+    b = TestNetworkControllerBackend(FakePlatformBackend())
+    b.SetReplayArgs('/tmp/nonexistant', wpr_modes.WPR_OFF, '3g', [])
+    b.UpdateReplay(FakeBrowserBackend())
+    self.assertIsNone(b.fake_replay_server)

tools/telemetry/telemetry/core/platform/platform_backend.py

@@ -4,6 +4,7 @@
 
 import weakref
 
+from telemetry.core.platform import network_controller_backend
 from telemetry.core.platform import profiling_controller_backend
 from telemetry.core.platform import tracing_controller_backend
 
@@ -59,6 +60,8 @@ class PlatformBackend(object):
       raise ValueError('Unsupported device: %s' % device.name)
     self._platform = None
     self._running_browser_backends = weakref.WeakSet()
+    self._network_controller_backend = (
+        network_controller_backend.NetworkControllerBackend(self))
     self._tracing_controller_backend = (
         tracing_controller_backend.TracingControllerBackend(self))
     self._profiling_controller_backend = (
@@ -82,6 +85,10 @@ class PlatformBackend(object):
   def running_browser_backends(self):
     return list(self._running_browser_backends)
 
+  @property
+  def network_controller_backend(self):
+    return self._network_controller_backend
+
   @property
   def tracing_controller_backend(self):
     return self._tracing_controller_backend
@@ -93,6 +100,10 @@ class PlatformBackend(object):
   def DidCreateBrowser(self, browser, browser_backend):
     self.SetFullPerformanceModeEnabled(True)
 
+    # TODO(slamm): Remove this call when replay browser_backend dependencies
+    # get moved to platform. https://crbug.com/423962
+    self._network_controller_backend.UpdateReplay(browser_backend)
+
   def DidStartBrowser(self, browser, browser_backend):
     assert browser not in self._running_browser_backends
     self._running_browser_backends.add(browser_backend)
@@ -104,6 +115,9 @@ class PlatformBackend(object):
         browser, browser_backend)
     self._profiling_controller_backend.WillCloseBrowser(
         browser_backend)
+    # TODO(slamm): Move this call when replay's life cycle is no longer
+    # tied to the browser. https://crbug.com/424777
+    self._network_controller_backend.StopReplay()
 
     is_last_browser = len(self._running_browser_backends) == 1
     if is_last_browser:

tools/telemetry/telemetry/core/possible_browser.py

@@ -17,9 +17,6 @@ class PossibleBrowser(possible_app.PossibleApp):
                                           target_os=target_os,
                                           finder_options=finder_options)
     self._supports_tab_control = supports_tab_control
-    self._archive_path = None
-    self._append_to_existing_wpr = False
-    self._make_javascript_deterministic = True
     self._credentials_path = None
 
   def __repr__(self):
@@ -55,11 +52,5 @@ class PossibleBrowser(possible_app.PossibleApp):
   def last_modification_time(self):
     return -1
 
-  def SetReplayArchivePath(self, archive_path, append_to_existing_wpr,
-                           make_javascript_deterministic):
-    self._archive_path = archive_path
-    self._append_to_existing_wpr = append_to_existing_wpr
-    self._make_javascript_deterministic = make_javascript_deterministic
-
   def SetCredentialsPath(self, credentials_path):
     self._credentials_path = credentials_path

tools/telemetry/telemetry/core/webpagereplay.py

@@ -12,7 +12,6 @@ import subprocess
 import sys
 import urllib
 
-from telemetry.core import platform
 from telemetry.core import util
 
 _REPLAY_DIR = os.path.join(
@@ -191,8 +190,7 @@ class ReplayServer(object):
     Raises:
       ReplayNotStartedError: if Replay start-up fails.
     """
-    is_posix = platform.GetHostPlatform().GetOSName() in ('linux', 'mac')
-
+    is_posix = sys.platform.startswith('linux') or sys.platform == 'darwin'
     logging.debug('Starting Web-Page-Replay: %s', self._cmd_line)
     with self._OpenLogFile() as log_fh:
       self.replay_process = subprocess.Popen(

tools/telemetry/telemetry/core/wpr_server.py

@@ -12,15 +12,14 @@ from telemetry.core import wpr_modes
 
 
 class ReplayServer(object):
-  def __init__(self, browser_backend, path, wpr_mode,
-               make_javascript_deterministic):
-    self._browser_backend = browser_backend
+  def __init__(self, browser_backend, archive_path, wpr_mode, netsim,
+               extra_wpr_args, make_javascript_deterministic):
     self._forwarder = None
     self._web_page_replay = None
 
-    wpr_args = browser_backend.browser_options.extra_wpr_args
-    if browser_backend.browser_options.netsim:
-      wpr_args.append('--net=%s' % browser_backend.browser_options.netsim)
+    wpr_args = list(extra_wpr_args)
+    if netsim:
+      wpr_args.append('--net=%s' % netsim)
     if wpr_mode == wpr_modes.WPR_APPEND:
       wpr_args.append('--append')
     elif wpr_mode == wpr_modes.WPR_RECORD:
@@ -33,7 +32,7 @@ class ReplayServer(object):
           '--https_root_ca_cert_path=%s' % browser_backend.wpr_ca_cert_path,
           ])
     self._web_page_replay = webpagereplay.ReplayServer(
-        path, self._browser_backend.forwarder_factory.host_ip,
+        archive_path, browser_backend.forwarder_factory.host_ip,
         browser_backend.wpr_port_pairs.http.local_port,
         browser_backend.wpr_port_pairs.https.local_port,
         (browser_backend.wpr_port_pairs.dns.local_port

tools/telemetry/telemetry/page/page_runner.py

@@ -30,8 +30,8 @@ class _RunState(object):
   def __init__(self, test):
     self.browser = None
 
+    # TODO(slamm): Remove _append_to_existing_wpr when replay lifetime changes.
     self._append_to_existing_wpr = False
-    self._last_archive_path = None
     self._first_browser = True
     self._test = test
     self._did_login_for_current_page = False
@@ -41,14 +41,25 @@ class _RunState(object):
   def StartBrowserIfNeeded(self, test, page_set, page, possible_browser,
                           finder_options):
     started_browser = not self.browser
-    # Create a browser.
-    if not self.browser:
+    wpr_mode = finder_options.browser_options.wpr_mode
+    if self._append_to_existing_wpr and wpr_mode == wpr_modes.WPR_RECORD:
+      wpr_mode = wpr_modes.WPR_APPEND
+    # Replay's life-cycle is tied to the browser. Start and Stop are handled by
+    # platform_backend.DidCreateBrowser and platform_backend.WillCloseBrowser,
+    # respectively.
+    # TODO(slamm): Update life-cycle comment with https://crbug.com/424777 fix.
+    possible_browser.platform.network_controller.SetReplayArgs(
+        page.archive_path, wpr_mode, finder_options.browser_options.netsim,
+        finder_options.browser_options.extra_wpr_args,
+        page_set.make_javascript_deterministic)
+
+    if self.browser:
+      # Set new credential path for browser.
+      self.browser.credentials.credentials_path = page.credentials_path
+      self.browser.platform.network_controller.UpdateReplayForExistingBrowser()
+    else:
       test.CustomizeBrowserOptionsForSinglePage(page, finder_options)
-      possible_browser.SetReplayArchivePath(page.archive_path,
-                                        self._append_to_existing_wpr,
-                                        page_set.make_javascript_deterministic)
       possible_browser.SetCredentialsPath(page.credentials_path)
-      self._last_archive_path = page.archive_path
 
       test.WillStartBrowser(possible_browser.platform)
       self.browser = possible_browser.Create()
@@ -83,16 +94,6 @@ class _RunState(object):
             logging.info('No GPU devices')
         else:
           logging.warning('System info not supported')
-    else:
-      # Set new credential path for browser.
-      self.browser.credentials.credentials_path = page.credentials_path
-      # Set up WPR path if it changed.
-      if page.archive_path and self._last_archive_path != page.archive_path:
-        self.browser.SetReplayArchivePath(
-            page.archive_path,
-            self._append_to_existing_wpr,
-            page_set.make_javascript_deterministic)
-        self._last_archive_path = page.archive_path
 
     if self.browser.supports_tab_control and test.close_tabs_before_run:
       # Create a tab if there's none.

tools/telemetry/telemetry/page/page_runner_unittest.py

@@ -15,6 +15,7 @@ from telemetry.core import browser_finder
 from telemetry.core import exceptions
 from telemetry.core import user_agent
 from telemetry.core import util
+from telemetry.core import wpr_modes
 from telemetry.page import page as page_module
 from telemetry.page import page_runner
 from telemetry.page import page_set
@@ -574,11 +575,13 @@ class PageRunnerTests(unittest.TestCase):
         self.is_page_from_archive = False
         self.archive_path_exist = True
 
+      def WillStartBrowser(self, platform):
+        self.is_page_from_archive = (
+            self.options.browser_options.wpr_mode != wpr_modes.WPR_OFF)
+
       def WillNavigateToPage(self, page, tab):
         self.archive_path_exist = (page.archive_path
                                    and os.path.isfile(page.archive_path))
-        self.is_page_from_archive = (
-          tab.browser._wpr_server is not None) # pylint: disable=W0212
 
       def ValidateAndMeasurePage(self, _, __, results):
         pass