Keep remote_inspector_client in sync with the latest changes in Blink.

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 263 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, url, tab_index, tab_filter, verbose, show_socket_messages):
+  def __init__(self, url, tab_index, tab_filter, verbose, show_socket_messages,
+               agent_name):
     """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
+    self._agent_name = agent_name
 
     # Create a DevToolsSocket client and wait for it to complete the remote
     # debugging protocol handshake with the remote Chrome instance.
     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:
@@ skipping 183 matching lines @@
           return request
     return None
 
   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':
+    if request.method == self._agent_name +'.takeHeapSnapshot':
       # We always want detailed v8 heap snapshot information.
       request.params = {'detailed': True}
-    elif request.method == 'Profiler.getHeapSnapshot':
+    elif request.method == self._agent_name + '.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')
+          self._agent_name + '.takeHeapSnapshot')
       if last_req and 'uid' in last_req.results:
         request.params = {'uid': last_req.results['uid']}
-    elif request.method == 'Profiler.getProfile':
+    elif request.method == self._agent_name + '.getProfile':
       # TODO(eustas): Remove this case after M27 is released.
       last_req = self._GetLatestRequestOfType(request,
-                                              'Profiler.takeHeapSnapshot')
+          self._agent_name + '.takeHeapSnapshot')
       if last_req and 'uid' in last_req.results:
         request.params = {'type': 'HEAP', 'uid': last_req.results['uid']}
 
   @staticmethod
   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
@@ skipping 309 matching lines @@
 
     # 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)
+    self._version = self._GetVersion(url)
+
+    # TODO(loislo): Remove this hack after M28 is released.
+    self._agent_name = 'Profiler'
+    if self._IsBrowserDayNumberMoreThan(1470):
+      self._agent_name = 'HeapProfiler'
 
     # Start up a thread for long-term communication with the remote inspector.
     self._remote_inspector_thread = _RemoteInspectorThread(
-        url, tab_index, tab_filter, verbose, show_socket_messages)
+        url, tab_index, tab_filter, verbose, show_socket_messages,
+        self._agent_name)
     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 17 matching lines @@
       {
         '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'
+    if self._IsPlatformVersionNotOlderThan(537, 27):
+      get_heap_snapshot_method = '.getHeapSnapshot'
     else:
-      get_heap_snapshot_method = 'Profiler.getProfile'
+      get_heap_snapshot_method = '.getProfile'
 
     HEAP_SNAPSHOT_MESSAGES = [
       ('Page.getResourceTree', {}),
       ('Debugger.enable', {}),
-      ('Profiler.clearProfiles', {}),
-      ('Profiler.takeHeapSnapshot', {}),
-      (get_heap_snapshot_method, {}),
+      (self._agent_name + '.clearProfiles', {}),
+      (self._agent_name + '.takeHeapSnapshot', {}),
+      (self._agent_name + 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.
 
       Args:
         reply_dict: A dictionary object representing the reply message received
                      from the remote inspector.
       """
       if 'result' in reply_dict:
         # This is the result message associated with a previously-sent request.
         request = self._remote_inspector_thread.GetRequestWithId(
             reply_dict['id'])
         if 'frameTree' in reply_dict['result']:
           self._url = reply_dict['result']['frameTree']['frame']['url']
       elif 'method' in reply_dict:
         # This is an auxiliary message sent from the remote Chrome instance.
-        if reply_dict['method'] == 'Profiler.addProfileHeader':
+        if reply_dict['method'] == self._agent_name + '.addProfileHeader':
           snapshot_req = (
               self._remote_inspector_thread.GetFirstUnfulfilledRequest(
-                  'Profiler.takeHeapSnapshot'))
+                  self._agent_name + '.takeHeapSnapshot'))
           if snapshot_req:
             snapshot_req.results['uid'] = reply_dict['params']['header']['uid']
-        elif reply_dict['method'] == 'Profiler.addHeapSnapshotChunk':
+        elif reply_dict['method'] == self._agent_name + '.addHeapSnapshotChunk':
           self._current_heap_snapshot.append(reply_dict['params']['chunk'])
-        elif reply_dict['method'] == 'Profiler.finishHeapSnapshot':
+        elif reply_dict['method'] == self._agent_name + '.finishHeapSnapshot':
           # A heap snapshot has been completed.  Analyze and output the data.
           self._logger.debug('Heap snapshot taken: %s', self._url)
           # TODO(dennisjeffrey): Parse the heap snapshot on-the-fly as the data
           # is coming in over the wire, so we can avoid storing the entire
           # snapshot string in memory.
           raw_snapshot_data = ''.join(self._current_heap_snapshot)
           self._collected_heap_snapshot_data = {
               'url': self._url,
               'raw_data': raw_snapshot_data}
           if include_summary:
@@ skipping 320 matching lines @@
       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.
+  def _GetVersion(endpoint):
+    """Fetches version information from a remote Chrome instance.
 
     Args:
       endpoint: The base URL to connent to.
 
     Returns:
-      A dictionary containing Webkit version information:
+      A dictionary containing Brownser and Content version information:

[dennis_jeffrey, 2013/04/10 17:21:34]

Brownser --> Browser

       {
-        'major': integer,
-        'minor': integer,
+        'Browser': {
+          'major': integer,
+          'minor': integer,
+          'fix': integer,
+          'day': integer
+        },
+        'Content': {
+          'name': string,
+          'major': integer,
+          'minor': integer
+        }
       }
 
     Raises:
-      RuntimeError: When Webkit version info can't be fetched or parsed.
+      RuntimeError: When Browser 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 'Browser' not in result:
+      raise RuntimeError('Browser version is not specified.')
+
+    parsed = re.search('^Chrome\/(\d+).(\d+).(\d+).(\d+)', result['Browser'])
+    if parsed is None:
+      raise RuntimeError('Browser-Version cannot be parsed.')
+    try:
+      day = int(parsed.group(3))
+      browser_info = {
+        'major': int(parsed.group(1)),
+        'minor': int(parsed.group(2)),
+        'day': day,
+        'fix': int(parsed.group(4)),
+      }
+    except ValueError:
+      raise RuntimeError('Browser-Version cannot be parsed.')
+
     if 'WebKit-Version' not in result:
-      raise RuntimeError('WebKit-Version is not specified.')
+      raise RuntimeError('Content-Version is not specified.')
 
     parsed = re.search('^(\d+)\.(\d+)', result['WebKit-Version'])
     if parsed is None:
-      raise RuntimeError('WebKit-Version cannot be parsed.')
+      raise RuntimeError('Content-Version cannot be parsed.')
 
     try:
-      info = {
+      platform_info = {
+        'name': 'Blink' if day > 1464 else 'WebKit',
         'major': int(parsed.group(1)),
         'minor': int(parsed.group(2)),
       }
     except ValueError:
       raise RuntimeError('WebKit-Version cannot be parsed.')
 
-    return info
+    return {
+      'browser': browser_info,
+      'platform': platform_info
+    }
 
-  def _IsWebkitVersionNotOlderThan(self, major, minor):
-    """Compares remote Webkit version with specified one.
+  def _IsContentVersionNotOlderThan(self, major, minor):
+    """Compares remote Browser Content 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,
+      True if remote Content version is same or newer than specified,
       False otherwise.
 
     Raises:
-      RuntimeError: If remote Webkit version hasn't been fetched yet.
+      RuntimeError: If remote Content 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 not hasattr(self, '_version'):
+      raise RuntimeError('Browser version has not been fetched yet.')
+    version = self._version['platform']
 
     if version['major'] < major:
       return False
     elif version['major'] == major and version['minor'] < minor:
       return False
     else:
       return True
+
+  def _IsBrowserDayNumberMoreThan(self, day_number):
+    """Compares remote Chromium day number with specified one.
+
+    Args:
+      day_number: Forth part of the chromium version.
+
+    Returns:
+      True if remote Chromium day number is same or newer than specified,
+      False otherwise.
+
+    Raises:
+      RuntimeError: If remote Chromium version hasn't been fetched yet.
+    """
+    if not hasattr(self, '_version'):
+      raise RuntimeError('Browser revision has not been fetched yet.')
+    version = self._version['browser']
+
+    return version['day'] > day_number