Adopt inspector protocol changes.

chrome/test/pyautolib/remote_inspector_client.py

 #!/usr/bin/env python
 # 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.
 
 """Chrome remote inspector utility for pyauto tests.
 
 This script provides a python interface that acts as a front-end for Chrome's
 remote inspector module, communicating via sockets to interact with Chrome in
 the same way that the Developer Tools does.  This -- in theory -- should allow
@@ skipping 23 matching lines @@
 at a time.  If a second instance is instantiated, a RuntimeError will be raised.
 RemoteInspectorClient could be made into a singleton in the future if the need
 for it arises.
 """
 
 import asyncore
 import datetime
 import logging
 import optparse
 import pprint
+import re
 import simplejson
 import socket
 import sys
 import threading
 import time
 import urllib2
 import urlparse
 
 
 class _DevToolsSocketRequest(object):
@@ skipping 219 matching lines @@
 class _RemoteInspectorThread(threading.Thread):
   """Manages communication using Chrome's remote inspector protocol.
 
   This class works in conjunction with the _DevToolsSocketClient class to
   communicate with a remote Chrome instance following the remote inspector
   communication protocol in WebKit.  This class performs the higher-level work
   of managing request and reply messages, whereas _DevToolsSocketClient handles
   the lower-level work of socket communication.
   """
 
-  def __init__(self, tab_index, tab_filter, verbose, show_socket_messages):
+  def __init__(self, url, tab_index, tab_filter, verbose, show_socket_messages):
     """Initialize.
 
     Args:
+      url: The base URL to connent to.
       tab_index: The integer index of the tab in the remote Chrome instance to
           use for snapshotting.
       tab_filter: When specified, is run over tabs of the remote Chrome
           instances to choose which one to connect to.
       verbose: A boolean indicating whether or not to use verbose logging.
       show_socket_messages: A boolean indicating whether or not to show the
           socket messages sent/received when communicating with the remote
           Chrome instance.
     """
     threading.Thread.__init__(self)
     self._logger = logging.getLogger('_RemoteInspectorThread')
     self._logger.setLevel([logging.WARNING, logging.DEBUG][verbose])
 
     self._killed = False
     self._requests = []
     self._action_queue = []
     self._action_queue_condition = threading.Condition()
     self._action_specific_callback = None  # Callback only for current action.
     self._action_specific_callback_lock = threading.Lock()
     self._general_callbacks = []  # General callbacks that can be long-lived.
     self._general_callbacks_lock = threading.Lock()
     self._condition_to_wait = None
 
     # Create a DevToolsSocket client and wait for it to complete the remote
     # debugging protocol handshake with the remote Chrome instance.
-    result = self._IdentifyDevToolsSocketConnectionInfo(tab_index, tab_filter)
+    result = self._IdentifyDevToolsSocketConnectionInfo(
+        url, tab_index, tab_filter)
     self._client = _DevToolsSocketClient(
         verbose, show_socket_messages, result['host'], result['port'],
         result['path'])
     self._client.inspector_thread = self
     while asyncore.socket_map:
       if self._client.handshake_done or self._killed:
         break
       asyncore.loop(timeout=1, count=1, use_poll=True)
 
   def ClientSocketExceptionOccurred(self):
@@ skipping 181 matching lines @@
   def _FillInParams(self, request):
     """Fills in parameters for requests as necessary before the request is sent.
 
     Args:
       request: The _DevToolsSocketRequest object associated with a request
                message that is about to be sent.
     """
     if request.method == 'Profiler.takeHeapSnapshot':
       # We always want detailed v8 heap snapshot information.
       request.params = {'detailed': True}
-    elif request.method == 'Profiler.getProfile':
+    elif request.method == 'Profiler.getHeapSnapshot':
       # To actually request the snapshot data from a previously-taken snapshot,
       # we need to specify the unique uid of the snapshot we want.
       # The relevant uid should be contained in the last
       # 'Profiler.takeHeapSnapshot' request object.
       last_req = self._GetLatestRequestOfType(request,
                                               'Profiler.takeHeapSnapshot')
       if last_req and 'uid' in last_req.results:
+        request.params = {'uid': last_req.results['uid']}
+    elif request.method == 'Profiler.getProfile':
+      # TODO(eustas): Remove this case after M27 is released.
+      last_req = self._GetLatestRequestOfType(request,
+                                              'Profiler.takeHeapSnapshot')
+      if last_req and 'uid' in last_req.results:
         request.params = {'type': 'HEAP', 'uid': last_req.results['uid']}
 
   @staticmethod
-  def _IdentifyDevToolsSocketConnectionInfo(tab_index, tab_filter):
+  def _IdentifyDevToolsSocketConnectionInfo(url, tab_index, tab_filter):
     """Identifies DevToolsSocket connection info from a remote Chrome instance.
 
     Args:
+      url: The base URL to connent to.
       tab_index: The integer index of the tab in the remote Chrome instance to
           which to connect.
       tab_filter: When specified, is run over tabs of the remote Chrome instance
           to choose which one to connect to.
 
     Returns:
       A dictionary containing the DevToolsSocket connection info:
       {
         'host': string,
         'port': integer,
         'path': string,
       }
 
     Raises:
       RuntimeError: When DevToolsSocket connection info cannot be identified.
     """
     try:
-      # TODO(dennisjeffrey): Do not assume port 9222.  The port should be passed
-      # as input to this function.
-      f = urllib2.urlopen('http://localhost:9222/json')
+      f = urllib2.urlopen(url + '/json')
       result = f.read()
       logging.debug(result)
       result = simplejson.loads(result)
     except urllib2.URLError, e:
       raise RuntimeError(
           'Error accessing Chrome instance debugging port: ' + str(e))
 
     if tab_filter:
       connect_to = filter(tab_filter, result)[0]
     else:
@@ skipping 278 matching lines @@
 
     logging.basicConfig()
     self._logger = logging.getLogger('RemoteInspectorClient')
     self._logger.setLevel([logging.WARNING, logging.DEBUG][verbose])
 
     # Creating _RemoteInspectorThread might raise an exception. This prevents an
     # AttributeError in the destructor.
     self._remote_inspector_thread = None
     self._remote_inspector_driver_thread = None
 
+    # TODO(dennisjeffrey): Do not assume port 9222. The port should be passed
+    # as input to this function.
+    url = 'http://localhost:9222'
+
+    self._webkit_version = self._GetWebkitVersion(url)
+
     # Start up a thread for long-term communication with the remote inspector.
     self._remote_inspector_thread = _RemoteInspectorThread(
-        tab_index, tab_filter, verbose, show_socket_messages)
+        url, tab_index, tab_filter, verbose, show_socket_messages)
     self._remote_inspector_thread.start()
     # At this point, a connection has already been made to the remote inspector.
 
     # This thread calls asyncore.loop, which activates the channel service.
     self._remote_inspector_driver_thread = _RemoteInspectorDriverThread()
     self._remote_inspector_driver_thread.start()
 
   def __del__(self):
     """Called on destruction of this object."""
     self.Stop()
@@ skipping 16 matching lines @@
       snapshot that was taken.
       {
         'url': string,  # URL of the webpage that was snapshotted.
         'raw_data': string, # The raw data as JSON string.
         'total_v8_node_count': integer,  # Total number of nodes in the v8 heap.
                                          # Only if |include_summary| is True.
         'total_heap_size': integer,  # Total v8 heap size (number of bytes).
                                      # Only if |include_summary| is True.
       }
     """
+    # TODO(eustas): Remove this hack after M27 is released.
+    if self._IsWebkitVersionNotOlderThan(537, 27):
+      get_heap_snapshot_method = 'Profiler.getHeapSnapshot'
+    else:
+      get_heap_snapshot_method = 'Profiler.getProfile'
+
     HEAP_SNAPSHOT_MESSAGES = [
       ('Page.getResourceTree', {}),
       ('Debugger.enable', {}),
       ('Profiler.clearProfiles', {}),
       ('Profiler.takeHeapSnapshot', {}),
-      ('Profiler.getProfile', {}),
+      (get_heap_snapshot_method, {}),
     ]
 
     self._current_heap_snapshot = []
     self._url = ''
     self._collected_heap_snapshot_data = {}
 
     done_condition = threading.Condition()
 
     def HandleReply(reply_dict):
       """Processes a reply message received from the remote Chrome instance.
@@ skipping 299 matching lines @@
 
     Returns:
       A human-readable string representation of the given number of bytes.
     """
     if num_bytes < 1024:
       return '%d B' % num_bytes
     elif num_bytes < 1048576:
       return '%.2f KB' % (num_bytes / 1024.0)
     else:
       return '%.2f MB' % (num_bytes / 1048576.0)
+
+  @staticmethod
+  def _GetWebkitVersion(endpoint):
+    """Fetches Webkit version information from a remote Chrome instance.
+
+    Args:
+      endpoint: The base URL to connent to.
+
+    Returns:
+      A dictionary containing Webkit version information:
+      {
+        'major': integer,
+        'minor': integer,
+      }
+
+    Raises:
+      RuntimeError: When Webkit version info can't be fetched or parsed.
+    """
+    try:
+      f = urllib2.urlopen(endpoint + '/json/version')
+      result = f.read();
+      result = simplejson.loads(result)
+    except urllib2.URLError, e:
+      raise RuntimeError(
+          'Error accessing Chrome instance debugging port: ' + str(e))
+
+    if 'WebKit-Version' not in result:
+      raise RuntimeError('WebKit-Version is not specified.')
+
+    parsed = re.search('^(\d+)\.(\d+)', result['WebKit-Version'])
+    if parsed is None:
+      raise RuntimeError('WebKit-Version cannot be parsed.')
+
+    try:
+      info = {
+        'major': int(parsed.group(1)),
+        'minor': int(parsed.group(2)),
+      }
+    except ValueError:
+      raise RuntimeError('WebKit-Version cannot be parsed.')
+
+    return info
+
+  def _IsWebkitVersionNotOlderThan(self, major, minor):
+    """Compares remote Webkit version with specified one.
+
+    Args:
+      major: Major Webkit version.
+      minor: Minor Webkit version.
+
+    Returns:
+      True if remote Webkit version is same or newer than specified,
+      False otherwise.
+
+    Raises:
+      RuntimeError: If remote Webkit version hasn't been fetched yet.
+    """
+    if not hasattr(self, '_webkit_version'):
+      raise RuntimeError('WebKit version has not been fetched yet.')
+    version = self._webkit_version
+
+    if version['major'] < major:
+      return False
+    elif version['major'] == major and version['minor'] < minor:
+      return False
+    else:
+      return True