Add WebUSB layout tests for device disconnection.

content/renderer/usb/web_usb_device_impl.cc

 // Copyright 2015 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 "content/renderer/usb/web_usb_device_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 216 matching lines @@
   }
   scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
 }
 
 }  // namespace
 
 WebUSBDeviceImpl::WebUSBDeviceImpl(device::usb::DevicePtr device,
                                    const blink::WebUSBDeviceInfo& device_info)
     : device_(std::move(device)),
       device_info_(device_info),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  device_.set_connection_error_handler([this]() { device_.reset(); });

[Ken Rockot(use gerrit already), 2016/03/02 01:54:19]

BTW after thinking about our previous discussion more, I think it would be a
stretch for the bindings to assume that they should always close the local
handle if remote endpoint closure is detected. So really, handling connection
errors explicitly is the right thing to do.

+}
 
 WebUSBDeviceImpl::~WebUSBDeviceImpl() {}
 
 const blink::WebUSBDeviceInfo& WebUSBDeviceImpl::info() const {
   return device_info_;
 }
 
 void WebUSBDeviceImpl::open(blink::WebUSBDeviceOpenCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->Open(base::Bind(&OnOpenDevice, base::Passed(&scoped_callbacks)));
+  if (device_)
+    device_->Open(base::Bind(&OnOpenDevice, base::Passed(&scoped_callbacks)));
 }
 
 void WebUSBDeviceImpl::close(blink::WebUSBDeviceCloseCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->Close(base::Bind(&OnDeviceClosed, base::Passed(&scoped_callbacks)));
+  if (device_)
+    device_->Close(
+        base::Bind(&OnDeviceClosed, base::Passed(&scoped_callbacks)));
 }
 
 void WebUSBDeviceImpl::getConfiguration(
     blink::WebUSBDeviceGetConfigurationCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->GetConfiguration(
-      base::Bind(&OnGetConfiguration, base::Passed(&scoped_callbacks)));
+  if (device_)
+    device_->GetConfiguration(
+        base::Bind(&OnGetConfiguration, base::Passed(&scoped_callbacks)));
 }
 
 void WebUSBDeviceImpl::setConfiguration(
     uint8_t configuration_value,
     blink::WebUSBDeviceSetConfigurationCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->SetConfiguration(
-      configuration_value,
-      base::Bind(&HandlePassFailDeviceOperation,
-                 base::Passed(&scoped_callbacks), kSetConfigurationFailed));
+  if (device_)
+    device_->SetConfiguration(
+        configuration_value,
+        base::Bind(&HandlePassFailDeviceOperation,
+                   base::Passed(&scoped_callbacks), kSetConfigurationFailed));
 }
 
 void WebUSBDeviceImpl::claimInterface(
     uint8_t interface_number,
     blink::WebUSBDeviceClaimInterfaceCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->ClaimInterface(
-      interface_number,
-      base::Bind(&HandlePassFailDeviceOperation,
-                 base::Passed(&scoped_callbacks), kClaimInterfaceFailed));
+  if (device_)
+    device_->ClaimInterface(
+        interface_number,
+        base::Bind(&HandlePassFailDeviceOperation,
+                   base::Passed(&scoped_callbacks), kClaimInterfaceFailed));
 }
 
 void WebUSBDeviceImpl::releaseInterface(
     uint8_t interface_number,
     blink::WebUSBDeviceReleaseInterfaceCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->ReleaseInterface(
-      interface_number,
-      base::Bind(&HandlePassFailDeviceOperation,
-                 base::Passed(&scoped_callbacks), kReleaseInterfaceFailed));
+  if (device_)
+    device_->ReleaseInterface(
+        interface_number,
+        base::Bind(&HandlePassFailDeviceOperation,
+                   base::Passed(&scoped_callbacks), kReleaseInterfaceFailed));
 }
 
 void WebUSBDeviceImpl::setInterface(
     uint8_t interface_number,
     uint8_t alternate_setting,
     blink::WebUSBDeviceSetInterfaceAlternateSettingCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->SetInterfaceAlternateSetting(
-      interface_number, alternate_setting,
-      base::Bind(&HandlePassFailDeviceOperation,
-                 base::Passed(&scoped_callbacks), kSetInterfaceFailed));
+  if (device_)
+    device_->SetInterfaceAlternateSetting(
+        interface_number, alternate_setting,
+        base::Bind(&HandlePassFailDeviceOperation,
+                   base::Passed(&scoped_callbacks), kSetInterfaceFailed));
 }
 
 void WebUSBDeviceImpl::clearHalt(
     uint8_t endpoint_number,
     blink::WebUSBDeviceClearHaltCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->ClearHalt(
-      endpoint_number,
-      base::Bind(&HandlePassFailDeviceOperation,
-                 base::Passed(&scoped_callbacks), kClearHaltFailed));
+  if (device_)
+    device_->ClearHalt(
+        endpoint_number,
+        base::Bind(&HandlePassFailDeviceOperation,
+                   base::Passed(&scoped_callbacks), kClearHaltFailed));
 }
 
 void WebUSBDeviceImpl::controlTransfer(
     const blink::WebUSBDevice::ControlTransferParameters& parameters,
     uint8_t* data,
     size_t data_size,
     unsigned int timeout,
     blink::WebUSBDeviceTransferCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
+  if (!device_)
+    return;
+
   device::usb::ControlTransferParamsPtr params =
       device::usb::ControlTransferParams::From(parameters);
   switch (parameters.direction) {
     case WebUSBDevice::TransferDirection::In:
       device_->ControlTransferIn(
           std::move(params), data_size, timeout,
           base::Bind(&OnTransferIn, base::Passed(&scoped_callbacks)));
       break;
     case WebUSBDevice::TransferDirection::Out: {
       std::vector<uint8_t> bytes;
@@ skipping 13 matching lines @@
 }
 
 void WebUSBDeviceImpl::transfer(
     blink::WebUSBDevice::TransferDirection direction,
     uint8_t endpoint_number,
     uint8_t* data,
     size_t data_size,
     unsigned int timeout,
     blink::WebUSBDeviceTransferCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
+  if (!device_)
+    return;
+
   switch (direction) {
     case WebUSBDevice::TransferDirection::In:
       device_->GenericTransferIn(
           endpoint_number, data_size, timeout,
           base::Bind(&OnTransferIn, base::Passed(&scoped_callbacks)));
       break;
     case WebUSBDevice::TransferDirection::Out: {
       std::vector<uint8_t> bytes;
       if (data)
         bytes.assign(data, data + data_size);
@@ skipping 12 matching lines @@
 
 void WebUSBDeviceImpl::isochronousTransfer(
     blink::WebUSBDevice::TransferDirection direction,
     uint8_t endpoint_number,
     uint8_t* data,
     size_t data_size,
     blink::WebVector<uint32_t> packet_lengths,
     unsigned int timeout,
     blink::WebUSBDeviceTransferCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
+  if (!device_)
+    return;
+
   switch (direction) {
     case WebUSBDevice::TransferDirection::In:
       device_->IsochronousTransferIn(
           endpoint_number, mojo::Array<uint32_t>::From(packet_lengths), timeout,
           base::Bind(&OnIsochronousTransferIn,
                      base::Passed(&scoped_callbacks)));
       break;
     case WebUSBDevice::TransferDirection::Out: {
       std::vector<uint8_t> bytes;
       if (data)
         bytes.assign(data, data + data_size);
       mojo::Array<uint8_t> mojo_bytes;
       mojo_bytes.Swap(&bytes);
       device_->IsochronousTransferOut(
           endpoint_number, std::move(mojo_bytes),
           mojo::Array<uint32_t>::From(packet_lengths), timeout,
           base::Bind(&OnIsochronousTransferOut,
                      base::Passed(&scoped_callbacks)));
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
-                            base::Passed(&scoped_callbacks),
-                            kDeviceResetFailed));
+  if (device_)
+    device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
+                              base::Passed(&scoped_callbacks),
+                              kDeviceResetFailed));
 }
 
 }  // namespace content