DevTools: do not retain android_usb_devices in their manager.

BUG=355611

Review URL: https://codereview.chromium.org/230773003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263037 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/devtools/adb/android_usb_device.h

@@ -9,6 +9,7 @@
 #include <queue>
 #include <vector>
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
 #include "chrome/browser/usb/usb_device_handle.h"
 
 namespace base {
@@ -76,7 +77,8 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
                    const std::string& serial,
                    int inbound_address,
                    int outbound_address,
-                   int zero_mask);
+                   int zero_mask,
+                   int interface_id);
 
   void InitOnCallerThread();
 
@@ -87,12 +89,10 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
             uint32 arg1,
             const std::string& body);
 
-  scoped_refptr<UsbDeviceHandle> usb_device() { return usb_device_; }
+  scoped_refptr<UsbDeviceHandle> usb_device() { return usb_handle_; }
 
   std::string serial() { return serial_; }
 
-  bool terminated() { return terminated_; }
-
   bool is_connected() { return is_connected_; }
 
  private:
@@ -105,7 +105,7 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
                            scoped_refptr<net::IOBuffer> buffer,
                            size_t result);
 
-  void ReadHeader(bool initial);
+  void ReadHeader();
   void ParseHeader(UsbTransferStatus status,
                    scoped_refptr<net::IOBuffer> buffer,
                    size_t result);
@@ -124,6 +124,7 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
 
   void TransferError(UsbTransferStatus status);
 
+  void TerminateIfReleased(scoped_refptr<UsbDeviceHandle> usb_handle);
   void Terminate();
 
   void SocketDeleted(uint32 socket_id);
@@ -133,18 +134,18 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
   scoped_ptr<crypto::RSAPrivateKey> rsa_key_;
 
   // Device info
-  scoped_refptr<UsbDeviceHandle> usb_device_;
+  scoped_refptr<UsbDeviceHandle> usb_handle_;
   std::string serial_;
   int inbound_address_;
   int outbound_address_;
   int zero_mask_;
+  int interface_id_;
 
   bool is_connected_;
   bool signature_sent_;
 
   // Created sockets info
   uint32 last_socket_id_;
-  bool terminated_;
   typedef std::map<uint32, AndroidUsbSocket*> AndroidUsbSockets;
   AndroidUsbSockets sockets_;
 
@@ -156,6 +157,8 @@ class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
   typedef std::vector<scoped_refptr<AdbMessage> > PendingMessages;
   PendingMessages pending_messages_;
 
+  base::WeakPtrFactory<AndroidUsbDevice> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AndroidUsbDevice);
 };
 

chrome/browser/devtools/adb/android_usb_socket.cc

@@ -33,18 +33,21 @@ AndroidUsbSocket::AndroidUsbSocket(scoped_refptr<AndroidUsbDevice> device,
       delete_callback_(delete_callback),
       local_id_(socket_id),
       remote_id_(0),
-      is_connected_(false),
-      is_closed_(false) {
+      is_connected_(false) {
 }
 
 AndroidUsbSocket::~AndroidUsbSocket() {
   DCHECK(CalledOnValidThread());
   if (is_connected_)
     Disconnect();
-  delete_callback_.Run(local_id_);
+  if (!delete_callback_.is_null())
+    delete_callback_.Run(local_id_);
 }
 
 void AndroidUsbSocket::HandleIncoming(scoped_refptr<AdbMessage> message) {
+  if (!device_)
+    return;
+
   CHECK_EQ(message->arg1, local_id_);
   switch (message->command) {
     case AdbMessage::kCommandOKAY:
@@ -79,9 +82,7 @@ void AndroidUsbSocket::HandleIncoming(scoped_refptr<AdbMessage> message) {
     case AdbMessage::kCommandCLSE:
       if (is_connected_)
         device_->Send(AdbMessage::kCommandCLSE, local_id_, 0, "");
-      is_connected_ = false;
-      is_closed_ = true;
-      RespondToReaders(true);
+      Terminated();
       // "this" can be NULL.
       break;
     default:
@@ -91,7 +92,13 @@ void AndroidUsbSocket::HandleIncoming(scoped_refptr<AdbMessage> message) {
 
 void AndroidUsbSocket::Terminated() {
   is_connected_ = false;
-  is_closed_ = true;
+
+  // Break the socket -> device connection, release the device.
+  delete_callback_.Run(local_id_);
+  delete_callback_.Reset();
+  device_ = NULL;
+
+  // Respond to pending callbacks.
   if (!connect_callback_.is_null()) {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
@@ -106,7 +113,7 @@ int AndroidUsbSocket::Read(net::IOBuffer* buffer,
                            int length,
                            const net::CompletionCallback& callback) {
   if (!is_connected_)
-    return is_closed_ ? 0 : net::ERR_SOCKET_NOT_CONNECTED;
+    return device_ ? net::ERR_SOCKET_NOT_CONNECTED : 0;
 
   if (read_buffer_.empty()) {
     read_requests_.push_back(IORequest(buffer, length, callback));
@@ -149,7 +156,7 @@ int AndroidUsbSocket::SetSendBufferSize(int32 size) {
 
 int AndroidUsbSocket::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-  if (device_->terminated())
+  if (!device_)
     return net::ERR_FAILED;
   connect_callback_ = callback;
   device_->Send(AdbMessage::kCommandOPEN, local_id_, 0, command_);
@@ -157,9 +164,10 @@ int AndroidUsbSocket::Connect(const net::CompletionCallback& callback) {
 }
 
 void AndroidUsbSocket::Disconnect() {
-  is_connected_ = false;
+  if (!device_)
+    return;
   device_->Send(AdbMessage::kCommandCLSE, local_id_, remote_id_, "");
-  RespondToReaders(true);
+  Terminated();
 }
 
 bool AndroidUsbSocket::IsConnected() const {

chrome/browser/devtools/adb/android_usb_socket.h

@@ -78,7 +78,6 @@ class AndroidUsbSocket : public net::StreamSocket,
   uint32 remote_id_;
   net::BoundNetLog net_log_;
   bool is_connected_;
-  bool is_closed_;
   std::string read_buffer_;
   net::CompletionCallback connect_callback_;
   std::deque<IORequest> read_requests_;

chrome/browser/devtools/android_device.cc

@@ -108,6 +108,10 @@ void UsbDeviceImpl::RunCommand(const std::string& command,
                                const CommandCallback& callback) {
   DCHECK(CalledOnValidThread());
   net::StreamSocket* socket = device_->CreateSocket(command);
+  if (!socket) {
+    callback.Run(net::ERR_CONNECTION_FAILED, std::string());
+    return;
+  }
   int result = socket->Connect(base::Bind(&UsbDeviceImpl::OpenedForCommand,
                                           this, callback, socket));
   if (result != net::ERR_IO_PENDING)
@@ -120,6 +124,10 @@ void UsbDeviceImpl::OpenSocket(const std::string& name,
   std::string socket_name =
       base::StringPrintf(kLocalAbstractCommand, name.c_str());
   net::StreamSocket* socket = device_->CreateSocket(socket_name);
+  if (!socket) {
+    callback.Run(net::ERR_CONNECTION_FAILED, NULL);
+    return;
+  }
   int result = socket->Connect(base::Bind(&UsbDeviceImpl::OnOpenSocket, this,
                                           callback, socket));
   if (result != net::ERR_IO_PENDING)