Replace browser_backend.options with browser_backend.find_options.

All the options used by browser_backends need to be moved from finder_options to browser options.

BUG=269131
TEST=trybot

Review URL: https://chromiumcodereview.appspot.com/23664002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@220665 0039d316-1c4b-4281-b951-d872f2087c98

tools/telemetry/telemetry/core/backends/browser_backend.py

@@ -14,16 +14,17 @@ class BrowserBackend(object):
 
   WEBPAGEREPLAY_HOST = '127.0.0.1'
 
-  def __init__(self, is_content_shell, supports_extensions, options,
+  def __init__(self, is_content_shell, supports_extensions, finder_options,
                tab_list_backend):
-    self.browser_type = options.browser_type
+    self.browser_type = finder_options.browser_type
     self.is_content_shell = is_content_shell
     self._supports_extensions = supports_extensions
-    self.options = options
+    # TODO(achuith): Replace with browser options. crbug.com/269131.
+    self.finder_options = finder_options
     self._browser = None
     self._tab_list_backend = tab_list_backend(self)
 
-  def AddReplayServerOptions(self, options):
+  def AddReplayServerOptions(self, finder_options):
     pass
 
   def SetBrowser(self, browser):
@@ -41,7 +42,7 @@ class BrowserBackend(object):
 
   @property
   def wpr_mode(self):
-    return self.options.wpr_mode
+    return self.finder_options.wpr_mode
 
   @property
   def supports_tab_control(self):

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

@@ -146,19 +146,18 @@ class WebviewBackendSettings(AndroidBrowserBackendSettings):
 class AndroidBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
   """The backend for controlling a browser instance running on Android.
   """
-  def __init__(self, options, backend_settings):
+  def __init__(self, finder_options, backend_settings):
     super(AndroidBrowserBackend, self).__init__(
         is_content_shell=backend_settings.is_content_shell,
-        supports_extensions=False, options=options)
-    if len(options.extensions_to_load) > 0:
+        supports_extensions=False, finder_options=finder_options)
+    if len(finder_options.extensions_to_load) > 0:
       raise browser_backend.ExtensionsNotSupportedException(
           'Android browser does not support extensions.')
     # Initialize fields so that an explosion during init doesn't break in Close.
-    self._options = options
     self._adb = backend_settings.adb
     self._backend_settings = backend_settings
     self._saved_cmdline = None
-    if not options.keep_test_server_ports:
+    if not finder_options.keep_test_server_ports:
       adb_commands.ResetTestServerPortAllocation()
     self._port = adb_commands.AllocateTestServerPort()
 
@@ -166,10 +165,10 @@ class AndroidBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
     self._adb.CloseApplication(self._backend_settings.package)
 
     if self._adb.Adb().CanAccessProtectedFileContents():
-      if not options.dont_override_profile:
+      if not finder_options.dont_override_profile:
         self._backend_settings.RemoveProfile()
-      if options.profile_dir:
-        self._backend_settings.PushProfile(options.profile_dir)
+      if finder_options.profile_dir:
+        self._backend_settings.PushProfile(finder_options.profile_dir)
 
     # Set up the command line.
     self._saved_cmdline = ''.join(self._adb.Adb().GetProtectedFileContents(

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

@@ -28,11 +28,11 @@ class ChromeBrowserBackend(browser_backend.BrowserBackend):
   once a remote-debugger port has been established."""
   # It is OK to have abstract methods. pylint: disable=W0223
 
-  def __init__(self, is_content_shell, supports_extensions, options):
+  def __init__(self, is_content_shell, supports_extensions, finder_options):
     super(ChromeBrowserBackend, self).__init__(
         is_content_shell=is_content_shell,
         supports_extensions=supports_extensions,
-        options=options,
+        finder_options=finder_options,
         tab_list_backend=tab_list_backend.TabListBackend)
     self._port = None
 
@@ -46,7 +46,8 @@ class ChromeBrowserBackend(browser_backend.BrowserBackend):
     self.webpagereplay_remote_http_port = self.webpagereplay_local_http_port
     self.webpagereplay_remote_https_port = self.webpagereplay_local_https_port
 
-    if options.dont_override_profile and not options_for_unittests.AreSet():
+    if (finder_options.dont_override_profile and
+        not options_for_unittests.AreSet()):
       sys.stderr.write('Warning: Not overriding profile. This can cause '
                        'unexpected effects due to profile-specific settings, '
                        'such as about:flags settings, cookies, and '
@@ -58,8 +59,8 @@ class ChromeBrowserBackend(browser_backend.BrowserBackend):
       self._extension_dict_backend = (
           extension_dict_backend.ExtensionDictBackend(self))
 
-  def AddReplayServerOptions(self, options):
-    options.append('--no-dns_forwarding')
+  def AddReplayServerOptions(self, finder_options):
+    finder_options.append('--no-dns_forwarding')
 
   @property
   def misc_web_contents_backend(self):
@@ -73,32 +74,34 @@ class ChromeBrowserBackend(browser_backend.BrowserBackend):
 
   def GetBrowserStartupArgs(self):
     args = []
-    args.extend(self.options.extra_browser_args)
+    args.extend(self.finder_options.extra_browser_args)
     args.append('--disable-background-networking')
     args.append('--metrics-recording-only')
     args.append('--no-first-run')
     args.append('--no-proxy-server')
-    if self.options.wpr_mode != wpr_modes.WPR_OFF:
+    if self.finder_options.wpr_mode != wpr_modes.WPR_OFF:
       args.extend(wpr_server.GetChromeFlags(
           self.WEBPAGEREPLAY_HOST,
           self.webpagereplay_remote_http_port,
           self.webpagereplay_remote_https_port))
     args.extend(user_agent.GetChromeUserAgentArgumentFromType(
-        self.options.browser_user_agent_type))
+        self.finder_options.browser_user_agent_type))
 
     extensions = [extension.local_path for extension in
-                  self.options.extensions_to_load if not extension.is_component]
+                  self.finder_options.extensions_to_load
+                  if not extension.is_component]
     extension_str = ','.join(extensions)
     if len(extensions) > 0:
       args.append('--load-extension=%s' % extension_str)
 
     component_extensions = [extension.local_path for extension in
-                  self.options.extensions_to_load if extension.is_component]
+                            self.finder_options.extensions_to_load
+                            if extension.is_component]
     component_extension_str = ','.join(component_extensions)
     if len(component_extensions) > 0:
       args.append('--load-component-extension=%s' % component_extension_str)
 
-    if self.options.no_proxy_server:
+    if self.finder_options.no_proxy_server:
       args.append('--no-proxy-server')
 
     return args
@@ -126,7 +129,7 @@ class ChromeBrowserBackend(browser_backend.BrowserBackend):
           (document.readyState == 'complete' ||
            document.readyState == 'interactive')
       """
-      for e in self.options.extensions_to_load:
+      for e in self.finder_options.extensions_to_load:
         if not e.extension_id in self._extension_dict_backend:
           return False
         extension_object = self._extension_dict_backend[e.extension_id]

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

@@ -17,13 +17,12 @@ class CrOSBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
   CHROME_PATHS = ['/opt/google/chrome/chrome ',
                   '/usr/local/opt/google/chrome/chrome ']
 
-  def __init__(self, browser_type, options, cri, is_guest):
+  def __init__(self, browser_type, finder_options, cri, is_guest):
     super(CrOSBrowserBackend, self).__init__(
         is_content_shell=False, supports_extensions=not is_guest,
-        options=options)
+        finder_options=finder_options)
     # Initialize fields so that an explosion during init doesn't break in Close.
     self._browser_type = browser_type
-    self._options = options
     self._cri = cri
     self._is_guest = is_guest
 
@@ -49,7 +48,7 @@ class CrOSBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
     # Copy extensions to temp directories on the device.
     # Note that we also perform this copy locally to ensure that
     # the owner of the extensions is set to chronos.
-    for e in options.extensions_to_load:
+    for e in finder_options.extensions_to_load:
       output = cri.RunCmdOnDevice(['mktemp', '-d', '/tmp/extension_XXXXX'])
       extension_dir = output[0].rstrip()
       cri.PushFile(e.path, extension_dir)
@@ -61,14 +60,14 @@ class CrOSBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
     util.WaitFor(lambda: self.IsBrowserRunning(), 20)  # pylint: disable=W0108
 
     # Delete test@test.test's cryptohome vault (user data directory).
-    if not options.dont_override_profile:
+    if not finder_options.dont_override_profile:
       logging.info('Deleting user\'s cryptohome vault (the user data dir)')
       self._cri.RunCmdOnDevice(
           ['cryptohome', '--action=remove', '--force', '--user=test@test.test'])
-    if options.profile_dir:
+    if finder_options.profile_dir:
       profile_dir = '/home/chronos/Default'
       cri.RunCmdOnDevice(['rm', '-rf', profile_dir])
-      cri.PushFile(options.profile_dir + '/Default', profile_dir)
+      cri.PushFile(finder_options.profile_dir + '/Default', profile_dir)
       cri.RunCmdOnDevice(['chown', '-R', 'chronos:chronos', profile_dir])
 
   def GetBrowserStartupArgs(self):
@@ -249,7 +248,7 @@ class CrOSBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
       self._cri.RmRF(self._login_ext_dir)
       self._login_ext_dir = None
 
-    for e in self._options.extensions_to_load:
+    for e in self.finder_options.extensions_to_load:
       self._cri.RmRF(os.path.dirname(e.local_path))
 
     self._cri = None

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

@@ -19,12 +19,12 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
   """The backend for controlling a locally-executed browser instance, on Linux,
   Mac or Windows.
   """
-  def __init__(self, options, executable, flash_path, is_content_shell,
+  def __init__(self, finder_options, executable, flash_path, is_content_shell,
                browser_directory, output_profile_path=None):
     super(DesktopBrowserBackend, self).__init__(
         is_content_shell=is_content_shell,
         supports_extensions=not is_content_shell,
-        options=options)
+        finder_options=finder_options)
 
     # Initialize fields so that an explosion during init doesn't break in Close.
     self._proc = None
@@ -42,7 +42,7 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
                       self._flash_path)
       self._flash_path = None
 
-    if len(options.extensions_to_load) > 0 and is_content_shell:
+    if len(finder_options.extensions_to_load) > 0 and is_content_shell:
       raise browser_backend.ExtensionsNotSupportedException(
           'Content shell does not support extensions.')
 
@@ -56,7 +56,7 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
     self._SetupProfile()
 
   def _SetupProfile(self):
-    if not self.options.dont_override_profile:
+    if not self.finder_options.dont_override_profile:
       if self._output_profile_path:
         # If both |_output_profile_path| and |profile_dir| are specified then
         # the calling code will throw an exception, so we don't need to worry
@@ -64,7 +64,7 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
         self._tmp_profile_dir = self._output_profile_path
       else:
         self._tmp_profile_dir = tempfile.mkdtemp()
-      profile_dir = self._profile_dir or self.options.profile_dir
+      profile_dir = self._profile_dir or self.finder_options.profile_dir
       if profile_dir:
         if self.is_content_shell:
           logging.critical('Profiles cannot be used with content shell')
@@ -79,7 +79,7 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
     env = os.environ.copy()
     env['CHROME_HEADLESS'] = '1'  # Don't upload minidumps.
     env['BREAKPAD_DUMP_LOCATION'] = self._tmp_minidump_dir
-    if not self.options.show_stdout:
+    if not self.finder_options.show_stdout:
       self._tmp_output_file = tempfile.NamedTemporaryFile('w', 0)
       self._proc = subprocess.Popen(
           args, stdout=self._tmp_output_file, stderr=subprocess.STDOUT, env=env)
@@ -105,7 +105,7 @@ class DesktopBrowserBackend(chrome_browser_backend.ChromeBrowserBackend):
         args.append('--enable-net-benchmarking')
       else:
         args.append('--enable-benchmarking')
-      if not self.options.dont_override_profile:
+      if not self.finder_options.dont_override_profile:
         args.append('--user-data-dir=%s' % self._tmp_profile_dir)
     return args
 

tools/telemetry/telemetry/core/backends/webdriver/webdriver_browser_backend.py

@@ -10,11 +10,11 @@ class WebDriverBrowserBackend(browser_backend.BrowserBackend):
   instance, on Linux, Mac, and Windows.
   """
 
-  def __init__(self, driver_creator, supports_extensions, options):
+  def __init__(self, driver_creator, supports_extensions, finder_options):
     super(WebDriverBrowserBackend, self).__init__(
         is_content_shell=False,
         supports_extensions=supports_extensions,
-        options=options,
+        finder_options=finder_options,
         tab_list_backend=webdriver_tab_list_backend.WebDriverTabListBackend)
 
     self._driver_creator = driver_creator

tools/telemetry/telemetry/core/browser.py

@@ -201,7 +201,7 @@ class Browser(object):
 
     profiler_class = profiler_finder.FindProfiler(profiler_name)
 
-    if not profiler_class.is_supported(self._browser_backend.options):
+    if not profiler_class.is_supported(self._browser_backend.finder_options):
       raise Exception('The %s profiler is not '
                       'supported on this platform.' % profiler_name)
 
@@ -232,8 +232,8 @@ class Browser(object):
     return self._browser_backend.GetTraceResultAndReset()
 
   def Start(self):
-    options = self._browser_backend.options
-    if options.clear_sytem_cache_for_browser_and_profile_on_start:
+    finder_options = self._browser_backend.finder_options
+    if finder_options.clear_sytem_cache_for_browser_and_profile_on_start:
       if self._platform.CanFlushIndividualFilesFromSystemCache():
         self._platform.FlushSystemCacheForDirectory(
             self._browser_backend.profile_directory)