Allow platform apps to be leak checked by providing tab_filter to choose the tab to inspect.

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 54 matching lines @@
     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).
     is_fulfilled_condition: A threading.Condition for waiting for the request to
         be fulfilled.
   """
+
   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
@@ skipping 19 matching lines @@
   communication protocol in WebKit.  This class performs the lower-level work
   of socket communication.
 
   Public Attributes:
     handshake_done: A boolean indicating whether or not the client has completed
         the required protocol handshake with the remote Chrome instance.
     inspector_thread: An instance of the _RemoteInspectorThread class that is
         working together with this class to communicate with a remote Chrome
         instance.
   """
+
   def __init__(self, verbose, show_socket_messages, hostname, port, path):
     """Initialize.
 
     Args:
       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.
       hostname: The string hostname of the DevToolsSocket to which to connect.
       port: The integer port number of the DevToolsSocket to which to connect.
@@ skipping 146 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, verbose, show_socket_messages):
+
+  def __init__(self, tab_index, tab_filter, verbose, show_socket_messages):
     """Initialize.
 
     Args:
       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)
+    result = self._IdentifyDevToolsSocketConnectionInfo(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 192 matching lines @@
       # 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 = {'type': 'HEAP', 'uid': last_req.results['uid']}
 
   @staticmethod
-  def _IdentifyDevToolsSocketConnectionInfo(tab_index):
+  def _IdentifyDevToolsSocketConnectionInfo(tab_index, tab_filter):
     """Identifies DevToolsSocket connection info from a remote Chrome instance.
 
     Args:
       tab_index: The integer index of the tab in the remote Chrome instance to
-                 which to connect.
+          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')
-      result = f.read();
+      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_index >= len(result):
-      raise RuntimeError(
-          'Specified tab index %d doesn\'t exist (%d tabs found)' %
-          (tab_index, len(result)))
+    if tab_filter:
+      connect_to = filter(tab_filter, result)[0]
+    else:
+      if tab_index >= len(result):
+        raise RuntimeError(
+            'Specified tab index %d doesn\'t exist (%d tabs found)' %
+            (tab_index, len(result)))
+      connect_to = result[tab_index]
 
-    if 'webSocketDebuggerUrl' not in result[tab_index]:
+    logging.debug(simplejson.dumps(connect_to))
+
+    if 'webSocketDebuggerUrl' not in connect_to:
       raise RuntimeError('No socket URL exists for the specified tab.')
 
-    socket_url = result[tab_index]['webSocketDebuggerUrl']
+    socket_url = connect_to['webSocketDebuggerUrl']
     parsed = urlparse.urlparse(socket_url)
     # On ChromeOS, the "ws://" scheme may not be recognized, leading to an
     # incorrect netloc (and empty hostname and port attributes) in |parsed|.
     # Change the scheme to "http://" to fix this.
     if not parsed.hostname or not parsed.port:
       socket_url = 'http' + socket_url[socket_url.find(':'):]
       parsed = urlparse.urlparse(socket_url)
       # Warning: |parsed.scheme| is incorrect after this point.
     return ({'host': parsed.hostname,
              'port': parsed.port,
@@ skipping 223 matching lines @@
 
   Public Methods:
     Stop: Close the connection to the remote inspector.  Should be called when
         a user is done using this module.
     HeapSnapshot: Takes a v8 heap snapshot and returns the summarized data.
     GetMemoryObjectCounts: Retrieves memory object count information.
     CollectGarbage: Forces a garbage collection.
     StartTimelineEventMonitoring: Starts monitoring for timeline events.
     StopTimelineEventMonitoring: Stops monitoring for timeline events.
   """
+
   # TODO(dennisjeffrey): Allow a user to specify a window index too (not just a
   # tab index), when running through PyAuto.
-  def __init__(self, tab_index=0, verbose=False, show_socket_messages=False):
+  def __init__(self, tab_index=0, tab_filter=None,
+               verbose=False, show_socket_messages=False):
     """Initialize.
 
     Args:
       tab_index: The integer index of the tab in the remote Chrome instance to
-                 which to connect.  Defaults to 0 (the first tab).
+          which to connect.  Defaults to 0 (the first tab).
+      tab_filter: When specified, is run over tabs of the remote Chrome
+          instance 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.
+          socket messages sent/received when communicating with the remote
+          Chrome instance.
     """
     self._tab_index = tab_index
+    self._tab_filter = tab_filter
     self._verbose = verbose
     self._show_socket_messages = show_socket_messages
 
     self._timeline_started = False
 
     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
 
     # Start up a thread for long-term communication with the remote inspector.
     self._remote_inspector_thread = _RemoteInspectorThread(
-        tab_index, verbose, show_socket_messages)
+        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 212 matching lines @@
       ('Memory.getProcessMemoryDistribution', {})
     ]
 
     reply_holder = [None]
     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 Chrome instance.
+            from the remote Chrome instance.
       """
       request_id = reply_dict['id']
       # GC command will have id = 0, the second command id = 1
       if request_id == 0:
         logging.info('Did garbage collection')
         return
       if request_id != 1:
         raise RuntimeError('Unexpected request_id: %d' % request_id)
       reply_holder[0] = reply_dict
       done_condition.acquire()
@@ skipping 108 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)