Add support for reading USB descriptors to the new Windows backend.

device/usb/usb_device_handle_win.cc

+// Copyright 2017 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_win.h"
+
+#include <usbioctl.h>
+#include <usbspec.h>
+#include <winioctl.h>
+#include <winusb.h>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
+#include "base/strings/string16.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/win/object_watcher.h"
+#include "components/device_event_log/device_event_log.h"
+#include "device/usb/usb_context.h"
+#include "device/usb/usb_descriptors.h"
+#include "device/usb/usb_device_win.h"
+#include "device/usb/usb_service.h"
+#include "net/base/io_buffer.h"
+
+namespace device {
+
+// Encapsulates waiting for the completion of an overlapped event.
+class UsbDeviceHandleWin::Request : public base::win::ObjectWatcher::Delegate {
+ public:
+  explicit Request(HANDLE handle)
+      : handle_(handle), event_(CreateEvent(nullptr, false, false, nullptr)) {
+    memset(&overlapped_, 0, sizeof(overlapped_));
+    overlapped_.hEvent = event_.Get();
+  }
+
+  ~Request() override {
+    if (callback_) {
+      SetLastError(ERROR_REQUEST_ABORTED);
+      std::move(callback_).Run(this, false, 0);
+    }
+  }
+
+  // Starts watching for completion of the overlapped event.
+  void MaybeStartWatching(
+      BOOL success,
+      base::OnceCallback<void(Request*, DWORD, size_t)> callback) {
+    callback_ = std::move(callback);
+    if (success) {
+      OnObjectSignaled(event_.Get());
+    } else {
+      DWORD error = GetLastError();
+      if (error == ERROR_IO_PENDING) {
+        watcher_.StartWatchingOnce(event_.Get(), this);
+      } else {
+        std::move(callback_).Run(this, error, 0);
+      }
+    }
+  }
+
+  OVERLAPPED* overlapped() { return &overlapped_; }
+
+  // base::win::ObjectWatcher::Delegate
+  void OnObjectSignaled(HANDLE object) override {
+    DCHECK_EQ(object, event_.Get());
+    DWORD size;
+    if (GetOverlappedResult(handle_, &overlapped_, &size, true))
+      std::move(callback_).Run(this, ERROR_SUCCESS, size);
+    else
+      std::move(callback_).Run(this, GetLastError(), 0);
+  }
+
+ private:
+  HANDLE handle_;
+  OVERLAPPED overlapped_;
+  base::win::ScopedHandle event_;
+  base::win::ObjectWatcher watcher_;
+  base::OnceCallback<void(Request*, DWORD, size_t)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(Request);
+};
+
+scoped_refptr<UsbDevice> UsbDeviceHandleWin::GetDevice() const {
+  return device_;
+}
+
+void UsbDeviceHandleWin::Close() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_)
+    return;
+
+  device_->HandleClosed(this);
+  device_ = nullptr;
+
+  if (hub_handle_.IsValid()) {
+    CancelIo(hub_handle_.Get());
+    hub_handle_.Close();
+  }
+
+  requests_.clear();
+}
+
+void UsbDeviceHandleWin::SetConfiguration(int configuration_value,
+                                          const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::ClaimInterface(int interface_number,
+                                        const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::ReleaseInterface(int interface_number,
+                                          const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::SetInterfaceAlternateSetting(
+    int interface_number,
+    int alternate_setting,
+    const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::ResetDevice(const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::ClearHalt(uint8_t endpoint,
+                                   const ResultCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!device_) {
+    callback.Run(false);
+    return;
+  }
+}
+
+void UsbDeviceHandleWin::ControlTransfer(UsbEndpointDirection direction,
+                                         TransferRequestType request_type,
+                                         TransferRecipient recipient,
+                                         uint8_t request,
+                                         uint16_t value,
+                                         uint16_t index,
+                                         scoped_refptr<net::IOBuffer> buffer,
+                                         size_t length,
+                                         unsigned int timeout,
+                                         const TransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!device_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(callback, USB_TRANSFER_DISCONNECT, nullptr, 0));
+    return;
+  }
+
+  if (hub_handle_.IsValid()) {
+    if (direction == USB_DIRECTION_INBOUND &&
+        request_type == TransferRequestType::STANDARD &&
+        recipient == TransferRecipient::DEVICE &&
+        request == USB_REQUEST_GET_DESCRIPTOR) {
+      if ((value >> 8) == USB_DEVICE_DESCRIPTOR_TYPE) {
+        auto* node_connection_info = new USB_NODE_CONNECTION_INFORMATION_EX;
+        node_connection_info->ConnectionIndex = device_->port_number();
+
+        Request* request = MakeRequest(hub_handle_.Get());
+        request->MaybeStartWatching(
+            DeviceIoControl(hub_handle_.Get(),
+                            IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX,
+                            node_connection_info, sizeof(*node_connection_info),
+                            node_connection_info, sizeof(*node_connection_info),
+                            nullptr, request->overlapped()),
+            base::Bind(&UsbDeviceHandleWin::GotNodeConnectionInformation,
+                       weak_factory_.GetWeakPtr(), callback,
+                       base::Owned(node_connection_info), buffer, length));
+        return;
+      } else if (((value >> 8) == USB_CONFIGURATION_DESCRIPTOR_TYPE) ||
+                 ((value >> 8) == USB_STRING_DESCRIPTOR_TYPE)) {
+        size_t size = sizeof(USB_DESCRIPTOR_REQUEST) + length;
+        scoped_refptr<net::IOBuffer> request_buffer(new net::IOBuffer(size));
+        USB_DESCRIPTOR_REQUEST* descriptor_request =
+            reinterpret_cast<USB_DESCRIPTOR_REQUEST*>(request_buffer->data());
+        descriptor_request->ConnectionIndex = device_->port_number();
+        descriptor_request->SetupPacket.bmRequest = BMREQUEST_DEVICE_TO_HOST;
+        descriptor_request->SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
+        descriptor_request->SetupPacket.wValue = value;
+        descriptor_request->SetupPacket.wIndex = index;
+        descriptor_request->SetupPacket.wLength = length;
+
+        Request* request = MakeRequest(hub_handle_.Get());
+        request->MaybeStartWatching(
+            DeviceIoControl(hub_handle_.Get(),
+                            IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
+                            request_buffer->data(), size,
+                            request_buffer->data(), size, nullptr,
+                            request->overlapped()),
+            base::Bind(&UsbDeviceHandleWin::GotDescriptorFromNodeConnection,
+                       weak_factory_.GetWeakPtr(), callback, request_buffer,
+                       buffer, length));
+        return;
+      }
+    }
+
+    // Unsupported transfer for hub.
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
+    return;
+  }
+
+  // Regular control transfers unimplemented.
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
+}
+
+void UsbDeviceHandleWin::IsochronousTransferIn(
+    uint8_t endpoint_number,
+    const std::vector<uint32_t>& packet_lengths,
+    unsigned int timeout,
+    const IsochronousTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void UsbDeviceHandleWin::IsochronousTransferOut(
+    uint8_t endpoint_number,
+    scoped_refptr<net::IOBuffer> buffer,
+    const std::vector<uint32_t>& packet_lengths,
+    unsigned int timeout,
+    const IsochronousTransferCallback& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+void UsbDeviceHandleWin::GenericTransfer(UsbEndpointDirection direction,
+                                         uint8_t endpoint_number,
+                                         scoped_refptr<net::IOBuffer> buffer,
+                                         size_t length,
+                                         unsigned int timeout,
+                                         const TransferCallback& callback) {
+  // This one must be callable from any thread.
+}
+
+const UsbInterfaceDescriptor* UsbDeviceHandleWin::FindInterfaceByEndpoint(
+    uint8_t endpoint_address) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return nullptr;
+}
+
+UsbDeviceHandleWin::UsbDeviceHandleWin(
+    scoped_refptr<UsbDeviceWin> device,
+    base::win::ScopedHandle handle,
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
+    : device_(std::move(device)),
+      hub_handle_(std::move(handle)),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      blocking_task_runner_(std::move(blocking_task_runner)),
+      weak_factory_(this) {}
+
+UsbDeviceHandleWin::~UsbDeviceHandleWin() {}
+
+UsbDeviceHandleWin::Request* UsbDeviceHandleWin::MakeRequest(HANDLE handle) {
+  auto request = base::MakeUnique<Request>(hub_handle_.Get());
+  Request* request_ptr = request.get();
+  requests_[request_ptr] = std::move(request);
+  return request_ptr;
+}
+
+std::unique_ptr<UsbDeviceHandleWin::Request> UsbDeviceHandleWin::UnlinkRequest(
+    UsbDeviceHandleWin::Request* request_ptr) {
+  auto it = requests_.find(request_ptr);
+  DCHECK(it != requests_.end());
+  std::unique_ptr<Request> request = std::move(it->second);
+  requests_.erase(it);
+  return request;
+}
+
+void UsbDeviceHandleWin::GotNodeConnectionInformation(
+    const TransferCallback& callback,
+    void* node_connection_info_ptr,
+    scoped_refptr<net::IOBuffer> buffer,
+    size_t buffer_length,
+    Request* request_ptr,
+    DWORD win32_result,
+    size_t bytes_transferred) {
+  USB_NODE_CONNECTION_INFORMATION_EX* node_connection_info =
+      static_cast<USB_NODE_CONNECTION_INFORMATION_EX*>(
+          node_connection_info_ptr);
+  std::unique_ptr<Request> request = UnlinkRequest(request_ptr);
+
+  if (win32_result != ERROR_SUCCESS) {
+    SetLastError(win32_result);
+    USB_PLOG(ERROR) << "Failed to get node connection information";
+    callback.Run(USB_TRANSFER_ERROR, nullptr, 0);
+    return;
+  }
+
+  DCHECK_EQ(bytes_transferred, sizeof(USB_NODE_CONNECTION_INFORMATION_EX));
+  bytes_transferred = std::min(sizeof(USB_DEVICE_DESCRIPTOR), buffer_length);
+  memcpy(buffer->data(), &node_connection_info->DeviceDescriptor,
+         bytes_transferred);
+  callback.Run(USB_TRANSFER_COMPLETED, buffer, bytes_transferred);
+}
+
+void UsbDeviceHandleWin::GotDescriptorFromNodeConnection(
+    const TransferCallback& callback,
+    scoped_refptr<net::IOBuffer> request_buffer,
+    scoped_refptr<net::IOBuffer> original_buffer,
+    size_t original_buffer_length,
+    Request* request_ptr,
+    DWORD win32_result,
+    size_t bytes_transferred) {
+  std::unique_ptr<Request> request = UnlinkRequest(request_ptr);
+
+  if (win32_result != ERROR_SUCCESS) {
+    SetLastError(win32_result);
+    USB_PLOG(ERROR) << "Failed to read descriptor from node connection";
+    callback.Run(USB_TRANSFER_ERROR, nullptr, 0);
+    return;
+  }
+
+  DCHECK_GE(bytes_transferred, sizeof(USB_DESCRIPTOR_REQUEST));
+  bytes_transferred -= sizeof(USB_DESCRIPTOR_REQUEST);
+  memcpy(original_buffer->data(),
+         request_buffer->data() + sizeof(USB_DESCRIPTOR_REQUEST),
+         bytes_transferred);
+  callback.Run(USB_TRANSFER_COMPLETED, original_buffer, bytes_transferred);
+}
+
+}  // namespace device