Fix 2 threading-related bugs in pyauto's remote inspector module.

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 343 matching lines @@
           self._requests.append(
               _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))
 
           request.is_fulfilled_condition.acquire()
-          self._condition_to_wait = request.is_fulfilled
+          self._condition_to_wait = request.is_fulfilled_condition
           request.is_fulfilled_condition.wait()
           request.is_fulfilled_condition.release()
 
           if self._killed:
             self._client.close()
             return
 
         # Clean up so things are ready for the next request.
         self._requests = []
 
@@ skipping 600 matching lines @@
     """
     if self._timeline_started:
       self._logger.warning('Timeline monitoring already started.')
       return
     TIMELINE_MESSAGES = [
       ('Timeline.start', {})
     ]
 
     self._event_callback = event_callback
 
+    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.
       """
+      if 'result' in reply_dict:
+        done_condition.acquire()
+        done_condition.notify()
+        done_condition.release()
       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.
+    # Tell the remote inspector to start the timeline.
     self._timeline_callback = HandleReply
     self._remote_inspector_thread.AddMessageCallback(self._timeline_callback)
     self._remote_inspector_thread.PerformAction(TIMELINE_MESSAGES, None)
+
+    done_condition.acquire()
+    done_condition.wait()
+    done_condition.release()
+
     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', {})
     ]
 
-    # Tell the remote inspector to stop the timeline.  We can return
-    # immediately, since there is no result for which to wait.
+    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.
+      """
+      if 'result' in reply_dict:
+        done_condition.acquire()
+        done_condition.notify()
+        done_condition.release()
+
+    # Tell the remote inspector to stop the timeline.
     self._remote_inspector_thread.RemoveMessageCallback(self._timeline_callback)
-    self._remote_inspector_thread.PerformAction(TIMELINE_MESSAGES, None)
+    self._remote_inspector_thread.PerformAction(TIMELINE_MESSAGES, HandleReply)
+
+    done_condition.acquire()
+    done_condition.wait()
+    done_condition.release()
+
     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)