[telemetry] Add a webdriver backend with support for IE.

tools/telemetry/telemetry/core/chrome/browser_backend.py

 # Copyright (c) 2012 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 urllib2
 import httplib
 import socket
 import json
 import re
 import sys
 
 from telemetry.core import util
 from telemetry.core import exceptions
 from telemetry.core import user_agent
 from telemetry.core import web_contents
 from telemetry.core import wpr_modes
 from telemetry.core import wpr_server
+from telemetry.core import browser_backend as _browser_backend
 from telemetry.core.chrome import extension_dict_backend
 from telemetry.core.chrome import tab_list_backend
 from telemetry.core.chrome import tracing_backend
 from telemetry.core.chrome import misc_web_contents_backend
 from telemetry.unittest import options_for_unittests
 
 class ExtensionsNotSupportedException(Exception):
   pass
 
-class BrowserBackend(object):
-  """A base class for browser backends. Provides basic functionality
+class BrowserBackend(_browser_backend.BrowserBackend): # pylint: disable=w0223
+  """A base class for chrome browser backends. Provides basic functionality
   once a remote-debugger port has been established."""
 
-  WEBPAGEREPLAY_HOST = '127.0.0.1'
-
   def __init__(self, is_content_shell, supports_extensions, options):
-    self.browser_type = options.browser_type
-    self.is_content_shell = is_content_shell
-    self._supports_extensions = supports_extensions
-    self.options = options
-    self._browser = None
+    super(BrowserBackend, self).__init__(
+        is_content_shell=is_content_shell,
+        supports_extensions=supports_extensions,
+        options=options,
+        tab_list_backend=tab_list_backend.TabListBackend)
     self._port = None
 
     self._inspector_protocol_version = 0
     self._chrome_branch_number = 0
     self._tracing_backend = None
 
     self.webpagereplay_local_http_port = util.GetAvailableLocalPort()
     self.webpagereplay_local_https_port = util.GetAvailableLocalPort()
     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():
       sys.stderr.write('Warning: Not overriding profile. This can cause '
                        'unexpected effects due to profile-specific settings, '
                        'such as about:flags settings, cookies, and '
                        'extensions.\n')
     self._misc_web_contents_backend = (
         misc_web_contents_backend.MiscWebContentsBackend(self))
-    self._tab_list_backend = tab_list_backend.TabListBackend(self)
     self._extension_dict_backend = None
     if supports_extensions:
       self._extension_dict_backend = (
           extension_dict_backend.ExtensionDictBackend(self))
 
-  def SetBrowser(self, browser):
-    self._browser = browser
-    self._tab_list_backend.Init()
-
-  @property
-  def browser(self):
-    return self._browser
-
-  @property
-  def supports_extensions(self):
-    """True if this browser backend supports extensions."""
-    return self._supports_extensions
+  def CustomizeReplayServerWithOptions(self, options):
+    options.append('--no-dns_forwarding')
 
   @property
   def misc_web_contents_backend(self):
     """Access to chrome://oobe/login page which is neither a tab nor an
     extension."""
     return self._misc_web_contents_backend
 
   @property
-  def tab_list_backend(self):
-    return self._tab_list_backend
-
-  @property
   def extension_dict_backend(self):
     return self._extension_dict_backend
 
   def GetBrowserStartupArgs(self):
     args = []
     args.extend(self.options.extra_browser_args)
     args.append('--disable-background-networking')
     args.append('--metrics-recording-only')
     args.append('--no-first-run')
     if self.options.wpr_mode != wpr_modes.WPR_OFF:
@@ skipping 14 matching lines @@
                   self.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:
       args.append('--no-proxy-server')
 
     return args
 
-  @property
-  def wpr_mode(self):
-    return self.options.wpr_mode
-
   def _WaitForBrowserToComeUp(self, timeout=None):
     def IsBrowserUp():
       try:
         self.Request('', timeout=timeout)
       except (socket.error, httplib.BadStatusLine, urllib2.URLError):
         return False
       else:
         return True
     try:
       util.WaitFor(IsBrowserUp, timeout=30)
@@ skipping 89 matching lines @@
     """Returns a user-friendly name for the process of the given |cmd_line|."""
     if 'nacl_helper_bootstrap' in cmd_line:
       return 'nacl_helper_bootstrap'
     if ':sandboxed_process' in cmd_line:
       return 'renderer'
     m = re.match(r'.* --type=([^\s]*) .*', cmd_line)
     if not m:
       return 'browser'
     return m.group(1)
 
-  def GetRemotePort(self, _):
-    return util.GetAvailableLocalPort()
-
   def Close(self):
     if self._tracing_backend:
       self._tracing_backend.Close()
       self._tracing_backend = None
-
-  def CreateForwarder(self, *port_pairs):
-    raise NotImplementedError()
-
-  def IsBrowserRunning(self):
-    raise NotImplementedError()
-
-  def GetStandardOutput(self):
-    raise NotImplementedError()
-
-  def GetStackTrace(self):
-    raise NotImplementedError()
-
-class DoNothingForwarder(object):
-  def __init__(self, *port_pairs):
-    self._host_port = port_pairs[0].local_port
-
-  @property
-  def url(self):
-    assert self._host_port
-    return 'http://127.0.0.1:%i' % self._host_port
-
-  def Close(self):
-    self._host_port = None