Handle USB device disconnection during early setup.

device/usb/usb_device_handle_impl.cc

 // Copyright 2014 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.
 
 #include "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <utility>
@@ skipping 812 matching lines @@
                    << ": " << ConvertPlatformUsbErrorToString(rv);
   }
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleImpl::SetConfigurationComplete,
                             this, rv == LIBUSB_SUCCESS, callback));
 }
 
 void UsbDeviceHandleImpl::SetConfigurationComplete(
     bool success,
     const ResultCallback& callback) {
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+
   if (success) {
     device_->RefreshActiveConfiguration();
     RefreshEndpointMap();
   }
   callback.Run(success);
 }
 
 void UsbDeviceHandleImpl::ClaimInterfaceOnBlockingThread(
     int interface_number,
     const ResultCallback& callback) {
   int rv = libusb_claim_interface(handle_, interface_number);
   scoped_refptr<InterfaceClaimer> interface_claimer;
   if (rv == LIBUSB_SUCCESS) {
     interface_claimer =
         new InterfaceClaimer(this, interface_number, task_runner_);
   } else {
     USB_LOG(EVENT) << "Failed to claim interface: "
                    << ConvertPlatformUsbErrorToString(rv);
   }
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClaimInterfaceComplete, this,
                             interface_claimer, callback));
 }
 
 void UsbDeviceHandleImpl::ClaimInterfaceComplete(
     scoped_refptr<InterfaceClaimer> interface_claimer,
     const ResultCallback& callback) {
+  if (!device_) {
+    // Ensure that the InterfaceClaimer is released on the blocking thread.
+    InterfaceClaimer* raw_interface_claimer = interface_claimer.get();
+    interface_claimer->AddRef();
+    interface_claimer = nullptr;
+    blocking_task_runner_->ReleaseSoon(FROM_HERE, raw_interface_claimer);
+    callback.Run(false);
+    return;
+  }
+
   if (interface_claimer) {
     claimed_interfaces_[interface_claimer->interface_number()] =
         interface_claimer;
     RefreshEndpointMap();
   }
   callback.Run(static_cast<bool>(interface_claimer));
 }
 
 void UsbDeviceHandleImpl::SetInterfaceAlternateSettingOnBlockingThread(
     int interface_number,
@@ skipping 11 matching lines @@
       base::Bind(&UsbDeviceHandleImpl::SetInterfaceAlternateSettingComplete,
                  this, interface_number, alternate_setting,
                  rv == LIBUSB_SUCCESS, callback));
 }
 
 void UsbDeviceHandleImpl::SetInterfaceAlternateSettingComplete(
     int interface_number,
     int alternate_setting,
     bool success,
     const ResultCallback& callback) {
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+
   if (success) {
     claimed_interfaces_[interface_number]->set_alternate_setting(
         alternate_setting);
     RefreshEndpointMap();
   }
   callback.Run(success);
 }
 
 void UsbDeviceHandleImpl::ResetDeviceOnBlockingThread(
     const ResultCallback& callback) {
@@ skipping 11 matching lines @@
   int rv = libusb_clear_halt(handle_, endpoint);
   if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to clear halt: "
                    << ConvertPlatformUsbErrorToString(rv);
   }
   task_runner_->PostTask(FROM_HERE, base::Bind(callback, rv == LIBUSB_SUCCESS));
 }
 
 void UsbDeviceHandleImpl::RefreshEndpointMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(device_);
   endpoint_map_.clear();
   const UsbConfigDescriptor* config = device_->active_configuration();
   if (config) {
     for (const auto& map_entry : claimed_interfaces_) {
       int interface_number = map_entry.first;
       const scoped_refptr<InterfaceClaimer>& claimed_iface = map_entry.second;
 
       for (const UsbInterfaceDescriptor& iface : config->interfaces) {
         if (iface.interface_number == interface_number &&
             iface.alternate_setting == claimed_iface->alternate_setting()) {
@@ skipping 190 matching lines @@
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device