Cleanup: make InspectorBackend no longer inherit from InspectorWebsocket.

BUG=423954

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

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

7 files changed, 60 insertions, 57 deletions

diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_backend.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_backend.py
index 5b2eee2..1d109ea 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_backend.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_backend.py
@@ -27,17 +27,18 @@ class InspectorException(Exception):
   pass
 
 
-class InspectorBackend(inspector_websocket.InspectorWebsocket):
+class InspectorBackend(object):
   def __init__(self, browser_backend, context, timeout=60):
-    super(InspectorBackend, self).__init__(self._HandleError)
-    self.RegisterDomain('Inspector', self._HandleInspectorDomainNotification)
+    self._websocket = inspector_websocket.InspectorWebsocket(self._HandleError)
+    self._websocket.RegisterDomain(
+        'Inspector', self._HandleInspectorDomainNotification)
 
     self._browser_backend = browser_backend
     self._context = context
 
     logging.debug('InspectorBackend._Connect() to %s', self.debugger_url)
     try:
-      self.Connect(self.debugger_url)
+      self._websocket.Connect(self.debugger_url)
     except (websocket.WebSocketException, util.TimeoutException):
       err_msg = sys.exc_info()[1]
       if not self._browser_backend.IsAppRunning():
@@ -47,16 +48,17 @@ class InspectorBackend(inspector_websocket.InspectorWebsocket):
       else:
         raise exceptions.DevtoolsTargetCrashException(self.app, err_msg)
 
-    self._console = inspector_console.InspectorConsole(self)
-    self._memory = inspector_memory.InspectorMemory(self)
-    self._page = inspector_page.InspectorPage(self, timeout=timeout)
-    self._runtime = inspector_runtime.InspectorRuntime(self)
-    self._timeline = inspector_timeline.InspectorTimeline(self)
-    self._network = inspector_network.InspectorNetwork(self)
+    self._console = inspector_console.InspectorConsole(self._websocket)
+    self._memory = inspector_memory.InspectorMemory(self._websocket)
+    self._page = inspector_page.InspectorPage(
+        self._websocket, timeout=timeout)
+    self._runtime = inspector_runtime.InspectorRuntime(self._websocket)
+    self._timeline = inspector_timeline.InspectorTimeline(self._websocket)
+    self._network = inspector_network.InspectorNetwork(self._websocket)
     self._timeline_model = None
 
   def __del__(self):
-    self.Disconnect()
+    self._websocket.Disconnect()
 
   @property
   def app(self):
@@ -238,13 +240,13 @@ class InspectorBackend(inspector_websocket.InspectorWebsocket):
     sys.stderr.write('The connection to Chrome was lost to the Inspector UI.\n')
     sys.stderr.write('Telemetry is waiting for the inspector to be closed...\n')
     super(InspectorBackend, self).Disconnect()
-    self._socket.close()
-    self._socket = None
+    self._websocket._socket.close()
+    self._websocket._socket = None
     def IsBack():
       if not self._IsInspectable():
         return False
       try:
-        self.Connect(self.debugger_url)
+        self._websocket.Connect(self.debugger_url)
       except exceptions.DevtoolsTargetCrashException, ex:
         if ex.message.message.find('Handshake Status 500') == 0:
           return False
@@ -267,12 +269,13 @@ class InspectorBackend(inspector_websocket.InspectorWebsocket):
     def OnClose():
       pass
 
-    self.RegisterDomain('HeapProfiler', OnNotification, OnClose)
+    self._websocket.RegisterDomain('HeapProfiler', OnNotification, OnClose)
 
-    self.SyncRequest({'method': 'Page.getResourceTree'}, timeout)
-    self.SyncRequest({'method': 'Debugger.enable'}, timeout)
-    self.SyncRequest({'method': 'HeapProfiler.takeHeapSnapshot'}, timeout)
+    self._websocket.SyncRequest({'method': 'Page.getResourceTree'}, timeout)
+    self._websocket.SyncRequest({'method': 'Debugger.enable'}, timeout)
+    self._websocket.SyncRequest(
+        {'method': 'HeapProfiler.takeHeapSnapshot'}, timeout)
     snapshot = ''.join(snapshot)
 
-    self.UnregisterDomain('HeapProfiler')
+    self._websocket.UnregisterDomain('HeapProfiler')
     return model.Model(snapshot)
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_console.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_console.py
index 525f048..19f4ea2 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_console.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_console.py
@@ -4,9 +4,9 @@
 
 
 class InspectorConsole(object):
-  def __init__(self, inspector_backend):
-    self._inspector_backend = inspector_backend
-    self._inspector_backend.RegisterDomain(
+  def __init__(self, inspector_websocket):
+    self._inspector_websocket = inspector_websocket
+    self._inspector_websocket.RegisterDomain(
         'Console',
         self._OnNotification,
         self._OnClose)
@@ -53,7 +53,7 @@ class InspectorConsole(object):
       method_name = 'enable'
     else:
       method_name = 'disable'
-    self._inspector_backend.SyncRequest({
+    self._inspector_websocket.SyncRequest({
         'method': 'Console.%s' % method_name
         })
     self._console_enabled = enabled
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_memory.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_memory.py
index 2710fb1..a1d5b6c 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_memory.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_memory.py
@@ -10,9 +10,9 @@ class InspectorMemoryException(Exception):
 class InspectorMemory(object):
   """Communicates with the remote inspector's Memory domain."""
 
-  def __init__(self, inspector_backend):
-    self._inspector_backend = inspector_backend
-    self._inspector_backend.RegisterDomain(
+  def __init__(self, inspector_websocket):
+    self._inspector_websocket = inspector_websocket
+    self._inspector_websocket.RegisterDomain(
         'Memory',
         self._OnNotification,
         self._OnClose)
@@ -34,7 +34,7 @@ class InspectorMemory(object):
       A dictionary containing the counts associated with "nodes", "documents",
       and "jsEventListeners".
     """
-    res = self._inspector_backend.SyncRequest({
+    res = self._inspector_websocket.SyncRequest({
       'method': 'Memory.getDOMCounters'
     }, timeout)
     if ('result' not in res or
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_network.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_network.py
index 7d9ef35..fad9abc 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_network.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_network.py
@@ -124,41 +124,41 @@ class InspectorNetworkResponseData(object):
 
 
 class InspectorNetwork(object):
-  def __init__(self, inspector_backend):
-    self._inspector_backend = inspector_backend
+  def __init__(self, inspector_websocket):
+    self._inspector_websocket = inspector_websocket
     self._http_responses = []
     self._served_from_cache = set()
     self._timeline_recorder = None
 
   def ClearCache(self, timeout=60):
     """Clears the browser's disk and memory cache."""
-    res = self._inspector_backend.SyncRequest({
+    res = self._inspector_websocket.SyncRequest({
         'method': 'Network.canClearBrowserCache'
         }, timeout)
     assert res['result'], 'Cache clearing is not supported by this browser.'
-    self._inspector_backend.SyncRequest({
+    self._inspector_websocket.SyncRequest({
         'method': 'Network.clearBrowserCache'
         }, timeout)
 
   def StartMonitoringNetwork(self):
     """Starts monitoring network notifications and recording HTTP responses."""
     self.ClearResponseData()
-    self._inspector_backend.RegisterDomain(
+    self._inspector_websocket.RegisterDomain(
         'Network',
         self._OnNetworkNotification,
         self._OnClose)
     request = {
         'method': 'Network.enable'
         }
-    self._inspector_backend.SyncRequest(request)
+    self._inspector_websocket.SyncRequest(request)
 
   def StopMonitoringNetwork(self):
     """Stops monitoring network notifications and recording HTTP responses."""
-    self._inspector_backend.UnregisterDomain('Network')
+    self._inspector_websocket.UnregisterDomain('Network')
     request = {
         'method': 'Network.disable'
         }
-    self._inspector_backend.SyncRequest(request)
+    self._inspector_websocket.SyncRequest(request)
 
   def GetResponseData(self):
     """Returns all recorded HTTP responses."""
@@ -185,7 +185,7 @@ class InspectorNetwork(object):
 
   def GetHTTPResponseBody(self, request_id, timeout=60):
     try:
-      res = self._inspector_backend.SyncRequest({
+      res = self._inspector_websocket.SyncRequest({
           'method': 'Network.getResponseBody',
           'params': {
               'requestId': request_id,
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_page.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_page.py
index 9cee92e..0a9d974 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_page.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_page.py
@@ -8,9 +8,9 @@ from telemetry.core import util
 
 
 class InspectorPage(object):
-  def __init__(self, inspector_backend, timeout=60):
-    self._inspector_backend = inspector_backend
-    self._inspector_backend.RegisterDomain(
+  def __init__(self, inspector_websocket, timeout=60):
+    self._inspector_websocket = inspector_websocket
+    self._inspector_websocket.RegisterDomain(
         'Page',
         self._OnNotification,
         self._OnClose)
@@ -59,7 +59,7 @@ class InspectorPage(object):
               'identifier': self._script_to_evaluate_on_commit['id'],
               }
           }
-      self._inspector_backend.SyncRequest(request)
+      self._inspector_websocket.SyncRequest(request)
       self._script_to_evaluate_on_commit = None
     if source:
       request = {
@@ -68,7 +68,7 @@ class InspectorPage(object):
               'scriptSource': source,
               }
           }
-      res = self._inspector_backend.SyncRequest(request)
+      res = self._inspector_websocket.SyncRequest(request)
       self._script_to_evaluate_on_commit = {
           'id': res['result']['identifier'],
           'source': source
@@ -78,7 +78,7 @@ class InspectorPage(object):
     request = {
         'method': 'Page.enable'
         }
-    res = self._inspector_backend.SyncRequest(request, timeout)
+    res = self._inspector_websocket.SyncRequest(request, timeout)
     assert len(res['result'].keys()) == 0
 
   def WaitForNavigate(self, timeout=60):
@@ -93,7 +93,7 @@ class InspectorPage(object):
     try:
       while self._navigation_pending and remaining_time > 0:
         remaining_time = max(timeout - (time.time() - start_time), 0.0)
-        self._inspector_backend.DispatchNotifications(remaining_time)
+        self._inspector_websocket.DispatchNotifications(remaining_time)
     except util.TimeoutException:
       # Since we pass remaining_time to DispatchNotifications, we need to
       # list the full timeout time in this message.
@@ -116,7 +116,7 @@ class InspectorPage(object):
             }
         }
     self._navigated_frame_ids = set()
-    res = self._inspector_backend.SyncRequest(request, timeout)
+    res = self._inspector_websocket.SyncRequest(request, timeout)
     if 'frameId' in res['result']:
       # Modern backends are returning frameId from Page.navigate.
       # Use it here to unblock upon precise navigation.
@@ -136,7 +136,7 @@ class InspectorPage(object):
     request = {
         'method': 'Page.getCookies'
         }
-    res = self._inspector_backend.SyncRequest(request, timeout)
+    res = self._inspector_websocket.SyncRequest(request, timeout)
     cookies = res['result']['cookies']
     for cookie in cookies:
       if cookie['name'] == name:
@@ -147,4 +147,4 @@ class InspectorPage(object):
     request = {
         'method': 'HeapProfiler.CollectGarbage'
         }
-    self._inspector_backend.SyncRequest(request, timeout)
+    self._inspector_websocket.SyncRequest(request, timeout)
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_runtime.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_runtime.py
index 5347398..9585e10 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_runtime.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_runtime.py
@@ -5,9 +5,9 @@ from telemetry.core import exceptions
 
 
 class InspectorRuntime(object):
-  def __init__(self, inspector_backend):
-    self._inspector_backend = inspector_backend
-    self._inspector_backend.RegisterDomain(
+  def __init__(self, inspector_websocket):
+    self._inspector_websocket = inspector_websocket
+    self._inspector_websocket.RegisterDomain(
         'Runtime',
         self._OnNotification,
         self._OnClose)
@@ -37,7 +37,7 @@ class InspectorRuntime(object):
     if context_id is not None:
       self.EnableAllContexts()
       request['params']['contextId'] = context_id
-    res = self._inspector_backend.SyncRequest(request, timeout)
+    res = self._inspector_websocket.SyncRequest(request, timeout)
     if 'error' in res:
       raise exceptions.EvaluateException(res['error']['message'])
 
@@ -53,6 +53,6 @@ class InspectorRuntime(object):
     """Allow access to iframes."""
     if not self._contexts_enabled:
       self._contexts_enabled = True
-      self._inspector_backend.SyncRequest({'method': 'Runtime.enable'},
-                                          timeout=30)
+      self._inspector_websocket.SyncRequest({'method': 'Runtime.enable'},
+                                            timeout=30)
     return self._max_context_id
diff --git a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_timeline.py b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_timeline.py
index ca8052c..3f47af5 100644
--- a/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_timeline.py
+++ b/tools/telemetry/telemetry/core/backends/chrome_inspector/inspector_timeline.py
@@ -33,9 +33,9 @@ class InspectorTimeline(timeline_recorder.TimelineRecorder):
     def __exit__(self, *args):
       self._tab.StopTimelineRecording()
 
-  def __init__(self, inspector_backend):
+  def __init__(self, inspector_websocket):
     super(InspectorTimeline, self).__init__()
-    self._inspector_backend = inspector_backend
+    self._inspector_websocket = inspector_websocket
     self._is_recording = False
     self._raw_events = None
 
@@ -48,7 +48,7 @@ class InspectorTimeline(timeline_recorder.TimelineRecorder):
     assert not self._is_recording, 'Start should only be called once.'
     self._raw_events = None
     self._is_recording = True
-    self._inspector_backend.RegisterDomain(
+    self._inspector_websocket.RegisterDomain(
         'Timeline', self._OnNotification, self._OnClose)
     # The 'bufferEvents' parameter below means that events should not be sent
     # individually as messages, but instead all at once when a Timeline.stop
@@ -65,7 +65,7 @@ class InspectorTimeline(timeline_recorder.TimelineRecorder):
       return None
     request = {'method': 'Timeline.stop'}
     result = self._SendSyncRequest(request)
-    self._inspector_backend.UnregisterDomain('Timeline')
+    self._inspector_websocket.UnregisterDomain('Timeline')
     self._is_recording = False
 
     # TODO: Backward compatibility. Needs to be removed when
@@ -93,7 +93,7 @@ class InspectorTimeline(timeline_recorder.TimelineRecorder):
     Raises:
       TabBackendException: The response indicates an error occurred.
     """
-    response = self._inspector_backend.SyncRequest(request, timeout)
+    response = self._inspector_websocket.SyncRequest(request, timeout)
     if 'error' in response:
       raise TabBackendException(response['error']['message'])
     return response['result']