Add RemoteInspectorClient.EvaluateJavascript to run javascript over the remote inspector protocl

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 52 matching lines @@
   Public Attributes:
     method: The string method name associated with this request.
     id: A unique integer id associated with this request.
     params: A dictionary of input parameters associated with this request.
     results: A dictionary of relevant results obtained from the remote Chrome
         instance that are associated with this request.
     is_fulfilled: A boolean indicating whether or not this request has been sent
         and all relevant results for it have been obtained (i.e., this value is
         True only if all results for this request are known).
   """
-  def __init__(self, method, message_id):
+  def __init__(self, method, params, message_id):
     """Initialize.
 
     Args:
       method: The string method name for this request.
       message_id: An integer id for this request, which is assumed to be unique
           from among all requests.
     """
     self.method = method
     self.id = message_id
-    self.params = {}
+    self.params = params
     self.results = {}
     self.is_fulfilled = False
 
   def __repr__(self):
     json_dict = {}
     json_dict['method'] = self.method
     json_dict['id'] = self.id
     if self.params:
       json_dict['params'] = self.params
     return simplejson.dumps(json_dict, separators=(',', ':'))
@@ skipping 232 matching lines @@
     """Start this thread; overridden from threading.Thread."""
     while not self._killed:
       if self._action_queue:
         # There's a request to the remote inspector that needs to be processed.
         messages, callback = self._action_queue.pop(0)
         self._action_specific_callback = callback
 
         # Prepare the request list.
         for message_id, message in enumerate(messages):
           self._requests.append(
-              _DevToolsSocketRequest(message, message_id))
+              _DevToolsSocketRequest(message[0], message[1], message_id))
 
         # Send out each request.  Wait until each request is complete before
         # sending the next request.
         for request in self._requests:
           self._FillInParams(request)
           self._client.SendMessage(str(request))
           while not request.is_fulfilled:
             if self._killed:
               self._client.close()
               return
@@ skipping 377 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.
       }
     """
     HEAP_SNAPSHOT_MESSAGES = [
-      'Page.getResourceTree',
-      'Debugger.enable',
-      'Profiler.clearProfiles',
-      'Profiler.takeHeapSnapshot',
-      'Profiler.getProfile',
+      ('Page.getResourceTree', {}),
+      ('Debugger.enable', {}),
+      ('Profiler.clearProfiles', {}),
+      ('Profiler.takeHeapSnapshot', {}),
+      ('Profiler.getProfile', {}),
     ]
 
     self._current_heap_snapshot = []
     self._url = ''
     self._collected_heap_snapshot_data = {}
 
     def HandleReply(reply_dict):
       """Processes a reply message received from the remote Chrome instance.
 
       Args:
@@ skipping 41 matching lines @@
             self._collected_heap_snapshot_data['total_heap_size'] = total_size
 
     # Tell the remote inspector to take a v8 heap snapshot, then wait until
     # the snapshot information is available to return.
     self._remote_inspector_thread.PerformAction(HEAP_SNAPSHOT_MESSAGES,
                                                 HandleReply)
     while not self._collected_heap_snapshot_data:
       time.sleep(0.1)
     return self._collected_heap_snapshot_data
 
+  def EvaluateJavaScript(self, expression):
+    """Evaluates a JavaScript expression and returns the result.
+
+    Sends a message containing the expression to the remote Chrome instance we
+    are connected to, and evaluates it in the context of the tab we are
+    connected to. Blocks until the result is available and returns it.
+
+    Returns:
+      A dictionary representing the result.

[dennis_jeffrey, 2012/05/22 17:14:05]

Is there a standard format for the result dictionary that can be described here
in the docstring?

[jochen (gone - plz use gerrit), 2012/05/23 08:20:48]

not really. It depends on what the expression evaluates to.

+    """
+    EVALUATE_MESSAGES = [
+      ('Runtime.evaluate', { 'expression': expression,
+                             'objectGroup': 'group',
+                             'returnByValue': True }),
+      ('Runtime.releaseObjectGroup', { 'objectGroup': 'group' })
+    ]
+
+    self._result = None
+    self._got_result = False
+
+    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 Chrome instance.
+      """
+      if 'result' in reply_dict and 'result' in reply_dict['result']:
+        self._result = reply_dict['result']['result']['value']
+        self._got_result = True
+
+    # Tell the remote inspector to evaluate the given expression, then wait
+    # until that information is available to return.
+    self._remote_inspector_thread.PerformAction(EVALUATE_MESSAGES,
+                                                HandleReply)
+    while not self._got_result:
+      time.sleep(0.1)
+    return self._result
+
   def GetMemoryObjectCounts(self):
     """Retrieves memory object count information.
 
     Returns:
       A dictionary containing the memory object count information:
       {
         'DOMNodeCount': integer,  # Total number of DOM nodes.
         'EventListenerCount': integer,  # Total number of event listeners.
       }
     """
     MEMORY_COUNT_MESSAGES = [
-      'Memory.getDOMNodeCount',
+      ('Memory.getDOMNodeCount', {})
     ]
 
     self._event_listener_count = None
     self._dom_node_count = None
 
     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
@@ skipping 20 matching lines @@
     while not self._event_listener_count or not self._dom_node_count:
       time.sleep(0.1)
     return {
       'DOMNodeCount': self._dom_node_count,
       'EventListenerCount': self._event_listener_count,
     }
 
   def CollectGarbage(self):
     """Forces a garbage collection."""
     COLLECT_GARBAGE_MESSAGES = [
-      'Profiler.collectGarbage',
+      ('Profiler.collectGarbage', {})
     ]
 
     # Tell the remote inspector to do a garbage collect.  We can return
     # immediately, since there is no result for which to wait.
     self._remote_inspector_thread.PerformAction(COLLECT_GARBAGE_MESSAGES, None)
 
   def StartTimelineEventMonitoring(self, event_callback):
     """Starts timeline event monitoring.
 
     Args:
       event_callback: A callable to invoke whenever a timeline event is observed
           from the remote inspector.  The callable should take a single input,
           which is a dictionary containing the detailed information of a
           timeline event.
     """
     if self._timeline_started:
       self._logger.warning('Timeline monitoring already started.')
       return
     TIMELINE_MESSAGES = [
-      'Timeline.start',
+      ('Timeline.start', {})
     ]
 
     self._event_callback = event_callback
 
     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 Chrome instance.
       """
       if reply_dict.get('method') == 'Timeline.eventRecorded':
         self._event_callback(reply_dict['params']['record'])
 
     # Tell the remote inspector to start the timeline.  We can return
     # immediately, since there is no result for which to wait.
     self._timeline_callback = HandleReply
     self._remote_inspector_thread.AddMessageCallback(self._timeline_callback)
     self._remote_inspector_thread.PerformAction(TIMELINE_MESSAGES, None)
     self._timeline_started = True
 
   def StopTimelineEventMonitoring(self):
     """Stops timeline event monitoring."""
     if not self._timeline_started:
       self._logger.warning('Timeline monitoring already stopped.')
       return
     TIMELINE_MESSAGES = [
-      'Timeline.stop',
+      ('Timeline.stop', {})
     ]
 
     # Tell the remote inspector to stop the timeline.  We can return
     # immediately, since there is no result for which to wait.
     self._remote_inspector_thread.RemoveMessageCallback(self._timeline_callback)
     self._remote_inspector_thread.PerformAction(TIMELINE_MESSAGES, None)
     self._timeline_started = False
 
   def _ConvertByteCountToHumanReadableString(self, num_bytes):
     """Converts an integer number of bytes into a human-readable string.
 
     Args:
       num_bytes: An integer number of bytes.
 
     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)