Add argument use_poll=True to asyncore.loop() calls in perf_snapshot.py.

chrome/test/pyautolib/perf_snapshot.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.
 
 """Performance snapshot utility for pyauto tests.
 
 Wrapper around Chrome DevTools (mimics the front-end) to collect profiling info
 associated with a Chrome tab.  This script collects snapshots of the v8
 (Javascript engine) heap associated with the Chrome tab.
@@ skipping 424 matching lines @@
     # 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)
     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)
+      asyncore.loop(timeout=1, count=1, use_poll=True)
 
   def NotifySocketClientException(self):
     """Notifies that the _DevToolsSocketClient encountered an exception."""
     self._killed = True
 
   def NotifyReply(self, msg):
     """Notifies of a reply message received from the remote Chrome instance.
 
     Args:
       msg: A string reply message received from the remote Chrome instance;
@@ skipping 496 matching lines @@
       }
     """
     snapshotter_thread = _PerformanceSnapshotterThread(
         self._tab_index, self._output_file, self._interval, self._num_snapshots,
         self._verbose, self._show_socket_messages, self._interactive_mode)
     snapshotter_thread.start()
     try:
       while asyncore.socket_map:
         if not snapshotter_thread.is_alive():
           break
-        asyncore.loop(timeout=1, count=1)
+        asyncore.loop(timeout=1, count=1, use_poll=True)
     except KeyboardInterrupt:
       pass
     self._logger.debug('Waiting for snapshotter thread to die...')
     snapshotter_thread.join()
     self._logger.debug('Done taking snapshots.')
     return snapshotter_thread.collected_heap_snapshot_data
 
   def GarbageCollect(self):
     """Forces a garbage collection."""
     gc_thread = _GarbageCollectThread(self._tab_index, self._verbose,
                                       self._show_socket_messages)
     gc_thread.start()
     try:
       while asyncore.socket_map:
         if not gc_thread.is_alive():
           break
-        asyncore.loop(timeout=1, count=1)
+        asyncore.loop(timeout=1, count=1, use_poll=True)
     except KeyboardInterrupt:
       pass
     gc_thread.join()
 
   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.
       }
     """
     mem_count_thread = _MemoryCountThread(self._tab_index, self._verbose,
                                           self._show_socket_messages)
     mem_count_thread.start()
     try:
       while asyncore.socket_map:
         if not mem_count_thread.is_alive():
           break
-        asyncore.loop(timeout=1, count=1)
+        asyncore.loop(timeout=1, count=1, use_poll=True)
     except KeyboardInterrupt:
       pass
     mem_count_thread.join()
     result = {
       'DOMNodeCount': mem_count_thread.dom_node_count,
       'EventListenerCount': mem_count_thread.event_listener_count,
     }
     return result
 
   def SetInteractiveMode(self):
@@ skipping 47 matching lines @@
 
   if options.interactive_mode:
     snapshotter.SetInteractiveMode()
 
   snapshotter.HeapSnapshot()
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())