swarming: Bump python-adb to 6e66b...

appengine/third_party/python-adb/adb/adb_protocol.py

 # Copyright 2014 Google Inc. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 231 matching lines @@
           # Will reentrantly call self._Add() via parent._OnRead()
           if not self._manager.ReadAndDispatch(timeout_ms=self._timeout_ms):
             # Failed to read from the device, the connection likely dropped.
             raise StopIteration()
           continue
         if isinstance(i, StopIteration):
           raise i
         return i
 
     def _Add(self, message):
-      self._queue.put(message.data)
+      self._queue.put(message)
 
     def _Close(self):
       self._queue.put(StopIteration())
 
   def __init__(self, manager, local_id, service_name, timeout_ms=None):
     # ID as given by the remote device.
     self.remote_id = 0
     # Service requested on the remote device.
     self.service_name = service_name
     # Self assigned local ID.
@@ skipping 56 matching lines @@
       # cases.
       logging.warning(
           'Unexpected remote ID: expected %d: %s', self.remote_id, message)
     if message.header.arg1 != self._local_id:
       raise InvalidResponseError(
           'Unexpected local ID: expected %d' % self._local_id, message)
     if cmd_name == 'CLSE':
       self._HasClosed()
       return
     if cmd_name == 'OKAY':
+      self._yielder._Add(message)
       return
     if cmd_name == 'WRTE':
       try:
         self._Write('OKAY', '')
       except usb_exceptions.WriteFailedError as e:
         _LOG.info('%s._OnRead(): Failed to reply OKAY: %s', self.port_path, e)
       self._yielder._Add(message)
       return
     if cmd_name == 'AUTH':
       self._manager._HandleAUTH(message)
       return
     if cmd_name == 'CNXN':
       self._manager.HandleCNXN(message)
       return
     # Unexpected message.
     assert False, message
 
   # Adaptors.
 
   def Write(self, data):
     self._Write('WRTE', data)
 
-  def ReadUntil(self, _):
+  def ReadUntil(self, finish_command='WRTE'):
     try:
-      return 'WRTE', self._yielder.next()
+      while True:
+        message = self._yielder.next()
+        if message.header.command_name == finish_command:
+          return message
     except StopIteration:
       raise InvalidResponseError('Never got \'WRTE\'', '<N/A>')
 
 
 class AdbConnectionManager(object):
   """Multiplexes the multiple connections."""
   # Maximum amount of data in an ADB packet. Value of MAX_PAYLOAD_V2 in adb.h.
   MAX_ADB_DATA = 256*1024
 
   def __init__(self, usb, banner, rsa_keys, auth_timeout_ms):
@@ skipping 94 matching lines @@
     can fill up memory.
 
     Args:
       service: The service on the device to talk to.
       command: The command to send to the service.
       timeout_ms: Timeout for USB packets, in milliseconds.
     """
     return self.Open('%s:%s' % (service, command), timeout_ms).__iter__()
 
   def Command(self, service, command='', timeout_ms=None):
-    return ''.join(self.StreamingCommand(service, command, timeout_ms))
+    return ''.join(msg.data for msg in self.StreamingCommand(service, command,
+                                                             timeout_ms))
 
   def ReadAndDispatch(self, timeout_ms=None):
     """Receive a response from the device."""
     with self._lock:
       try:
         msg = _AdbMessage.Read(self._usb, timeout_ms)
       except usb_exceptions.ReadFailedError as e:
         # adbd could be rebooting, etc. Return None to signal that this kind of
         # failure is expected.
         _LOG.info(
@@ skipping 103 matching lines @@
     msg.Write(self._usb)
     return _AdbMessage.Read(self._usb, auth_timeout_ms)
 
   def _Unregister(self, conn_id):
     with self._lock:
       self._UnregisterLocked(conn_id)
 
   def _UnregisterLocked(self, conn_id):
     # self._lock must be held.
     self._connections.pop(conn_id, None)