[Telemetry] Move WPR life cycle from browser to platform

tools/perf/profile_creators/profile_extender.py

 # Copyright 2013 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 copy
 
 from telemetry.core import platform
 from telemetry.util import wpr_modes
 from telemetry.internal.browser import browser_finder
 from telemetry.internal.browser import browser_finder_exceptions
@@ skipping 17 matching lines @@
       then a new profile is created. Otherwise, the existing profile is
       appended on to.
     """
     self._finder_options = copy.deepcopy(finder_options)
     # Since profile extenders are not supported on remote platforms,
     # this should be the same as target platform.
     self._os_name = platform.GetHostPlatform().GetOSName()
 
     # A reference to the browser that will be performing all of the tab
     # navigations.
-    # This member is initialized during SetUpBrowser().
+    # These members are initialized during SetUpBrowser().
+    self._possible_browser = None
     self._browser = None
 
   def Run(self):
     """Creates or extends the profile."""
     raise NotImplementedError()
 
   def WebPageReplayArchivePath(self):
     """Returns the path to the WPR archive.
 
     Can be overridden by subclasses.
@@ skipping 32 matching lines @@
   def SetUpBrowser(self):
     """Finds and starts the browser.
 
     Can be overridden by subclasses. The subclass implementation must call the
     super class implementation.
 
     Subclasses do not need to call this method. This method is only necessary
     if the subclass needs to start a browser. If a subclass does call this
     method, the subclass must also call TearDownBrowser().
     """
-    possible_browser = self._GetPossibleBrowser(self.finder_options)
+    self._possible_browser = self._GetPossibleBrowser(self.finder_options)
     enabled_os_list = self.EnabledOSList()
     if self._os_name not in enabled_os_list:
       raise NotImplementedError(
         'This profile extender on %s is not yet supported'
         % self._os_name)
-    if possible_browser.IsRemote():
+    if self._possible_browser.IsRemote():
       raise NotImplementedError(
         'Profile extenders are not yet supported on remote platforms.')
-    assert possible_browser.supports_tab_control
+    assert self._possible_browser.supports_tab_control
 
-    self._SetUpWebPageReplay(self.finder_options, possible_browser)
+    self._SetUpWebPageReplay(self.finder_options)
     self._browser = possible_browser.Create(self.finder_options)
 
   def TearDownBrowser(self):
     """Tears down the browser.
 
     Can be overridden by subclasses. The subclass implementation must call the
     super class implementation.
     """
     if self._browser:
       self._browser.Close()
       self._browser = None
+    if self._possible_browser:
+      self._possible_browser.platform.network_controller.Close()
 
   def FetchWebPageReplayArchives(self):
     """Fetches the web page replay archives.
 
     Can be overridden by subclasses.
     """
     pass
 
-  def _SetUpWebPageReplay(self, finder_options, possible_browser):
+  def _SetUpWebPageReplay(self, finder_options):
     """Sets up Web Page Replay, if necessary."""
 
     wpr_archive_path = self.WebPageReplayArchivePath()
     if not wpr_archive_path:
       return
 
     self.FetchWebPageReplayArchives()
 
-    # The browser options needs to be passed to both the network controller
-    # as well as the browser backend.
     browser_options = finder_options.browser_options
     if finder_options.use_live_sites:
-      browser_options.wpr_mode = wpr_modes.WPR_OFF
+      wpr_mode = wpr_modes.WPR_OFF
     else:
-      browser_options.wpr_mode = wpr_modes.WPR_REPLAY
+      wpr_mode = wpr_modes.WPR_REPLAY
 
-    network_controller = possible_browser.platform.network_controller
-    make_javascript_deterministic = True
-
-    network_controller.SetReplayArgs(
-        wpr_archive_path, browser_options.wpr_mode, browser_options.netsim,
-        browser_options.extra_wpr_args, make_javascript_deterministic)
+    network_controller = self._possible_browser.platform.network_controller
+    network_controller.Open(
+        wpr_mode, browser_options.netsim, browser_options.extra_wpr_args)
+    network_controller.StartReplay(
+        wpr_archive_path, make_javascript_deterministic=True)
 
   def _GetPossibleBrowser(self, finder_options):
     """Return a possible_browser with the given options."""
     possible_browser = browser_finder.FindBrowser(finder_options)
     if not possible_browser:
       raise browser_finder_exceptions.BrowserFinderException(
           'No browser found.\n\nAvailable browsers:\n%s\n' %
           '\n'.join(browser_finder.GetAllAvailableBrowserTypes(finder_options)))
     finder_options.browser_options.browser_type = (
         possible_browser.browser_type)
 
     return possible_browser
-