Move classes in the device.usb Mojo namespace to device.mojom

third_party/WebKit/Source/modules/webusb/USBDevice.cpp

 // 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 "modules/webusb/USBDevice.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/webusb/USBConfiguration.h"
 #include "modules/webusb/USBControlTransferParameters.h"
 #include "modules/webusb/USBInTransferResult.h"
 #include "modules/webusb/USBIsochronousInTransferResult.h"
 #include "modules/webusb/USBIsochronousOutTransferResult.h"
 #include "modules/webusb/USBOutTransferResult.h"
 #include "platform/mojo/MojoHelper.h"
 #include "platform/wtf/Assertions.h"
 #include "public/platform/Platform.h"
 
-namespace usb = device::usb::blink;
+using device::mojom::blink::UsbControlTransferParamsPtr;
+using device::mojom::blink::UsbControlTransferType;
+using device::mojom::blink::UsbControlTransferRecipient;
+using device::mojom::blink::UsbDeviceInfoPtr;
+using device::mojom::blink::UsbDevicePtr;
+using device::mojom::blink::UsbIsochronousPacketPtr;
+using device::mojom::blink::UsbOpenDeviceError;
+using device::mojom::blink::UsbTransferDirection;
+using device::mojom::blink::UsbTransferStatus;
 
 namespace blink {
 
 namespace {
 
 const char kDeviceStateChangeInProgress[] =
     "An operation that changes the device state is in progress.";
 const char kDeviceUnavailable[] = "Device unavailable.";
 const char kInterfaceNotFound[] =
     "The interface number provided is not supported by the device in its "
     "current configuration.";
 const char kInterfaceStateChangeInProgress[] =
     "An operation that changes interface state is in progress.";
 const char kOpenRequired[] = "The device must be opened first.";
 
-DOMException* ConvertFatalTransferStatus(const usb::TransferStatus& status) {
+DOMException* ConvertFatalTransferStatus(const UsbTransferStatus& status) {
   switch (status) {
-    case usb::TransferStatus::TRANSFER_ERROR:
+    case UsbTransferStatus::TRANSFER_ERROR:
       return DOMException::Create(kNetworkError,
                                   "A transfer error has occured.");
-    case usb::TransferStatus::PERMISSION_DENIED:
+    case UsbTransferStatus::PERMISSION_DENIED:
       return DOMException::Create(kSecurityError,
                                   "The transfer was not allowed.");
-    case usb::TransferStatus::TIMEOUT:
+    case UsbTransferStatus::TIMEOUT:
       return DOMException::Create(kTimeoutError, "The transfer timed out.");
-    case usb::TransferStatus::CANCELLED:
+    case UsbTransferStatus::CANCELLED:
       return DOMException::Create(kAbortError, "The transfer was cancelled.");
-    case usb::TransferStatus::DISCONNECT:
+    case UsbTransferStatus::DISCONNECT:
       return DOMException::Create(kNotFoundError, kDeviceUnavailable);
-    case usb::TransferStatus::COMPLETED:
-    case usb::TransferStatus::STALLED:
-    case usb::TransferStatus::BABBLE:
-    case usb::TransferStatus::SHORT_PACKET:
+    case UsbTransferStatus::COMPLETED:
+    case UsbTransferStatus::STALLED:
+    case UsbTransferStatus::BABBLE:
+    case UsbTransferStatus::SHORT_PACKET:
       return nullptr;
     default:
       ASSERT_NOT_REACHED();
       return nullptr;
   }
 }
 
-String ConvertTransferStatus(const usb::TransferStatus& status) {
+String ConvertTransferStatus(const UsbTransferStatus& status) {
   switch (status) {
-    case usb::TransferStatus::COMPLETED:
-    case usb::TransferStatus::SHORT_PACKET:
+    case UsbTransferStatus::COMPLETED:
+    case UsbTransferStatus::SHORT_PACKET:
       return "ok";
-    case usb::TransferStatus::STALLED:
+    case UsbTransferStatus::STALLED:
       return "stall";
-    case usb::TransferStatus::BABBLE:
+    case UsbTransferStatus::BABBLE:
       return "babble";
     default:
       ASSERT_NOT_REACHED();
       return "";
   }
 }
 
 Vector<uint8_t> ConvertBufferSource(
     const ArrayBufferOrArrayBufferView& buffer) {
   ASSERT(!buffer.isNull());
   Vector<uint8_t> vector;
   if (buffer.isArrayBuffer())
     vector.Append(static_cast<uint8_t*>(buffer.getAsArrayBuffer()->Data()),
                   buffer.getAsArrayBuffer()->ByteLength());
   else
     vector.Append(static_cast<uint8_t*>(
                       buffer.getAsArrayBufferView().View()->BaseAddress()),
                   buffer.getAsArrayBufferView().View()->byteLength());
   return vector;
 }
 
 }  // namespace
 
-USBDevice::USBDevice(usb::DeviceInfoPtr device_info,
-                     usb::DevicePtr device,
+USBDevice::USBDevice(UsbDeviceInfoPtr device_info,
+                     UsbDevicePtr device,
                      ExecutionContext* context)
     : ContextLifecycleObserver(context),
       device_info_(std::move(device_info)),
       device_(std::move(device)),
       opened_(false),
       device_state_change_in_progress_(false),
       configuration_index_(-1) {
   if (device_) {
     device_.set_connection_error_handler(ConvertToBaseCallback(
         WTF::Bind(&USBDevice::OnConnectionError, WrapWeakPersistent(this))));
@@ skipping 465 matching lines @@
 }
 
 bool USBDevice::AnyInterfaceChangeInProgress() const {
   for (size_t i = 0; i < interface_state_change_in_progress_.size(); ++i) {
     if (interface_state_change_in_progress_.QuickGet(i))
       return true;
   }
   return false;
 }
 
-usb::ControlTransferParamsPtr USBDevice::ConvertControlTransferParameters(
+UsbControlTransferParamsPtr USBDevice::ConvertControlTransferParameters(
     const USBControlTransferParameters& parameters,
     ScriptPromiseResolver* resolver) const {
-  auto mojo_parameters = usb::ControlTransferParams::New();
+  auto mojo_parameters = device::mojom::blink::UsbControlTransferParams::New();
 
   if (parameters.requestType() == "standard") {
-    mojo_parameters->type = usb::ControlTransferType::STANDARD;
+    mojo_parameters->type = UsbControlTransferType::STANDARD;
   } else if (parameters.requestType() == "class") {
-    mojo_parameters->type = usb::ControlTransferType::CLASS;
+    mojo_parameters->type = UsbControlTransferType::CLASS;
   } else if (parameters.requestType() == "vendor") {
-    mojo_parameters->type = usb::ControlTransferType::VENDOR;
+    mojo_parameters->type = UsbControlTransferType::VENDOR;
   } else {
     resolver->Reject(DOMException::Create(
         kTypeMismatchError,
         "The control transfer requestType parameter is invalid."));
     return nullptr;
   }
 
   if (parameters.recipient() == "device") {
-    mojo_parameters->recipient = usb::ControlTransferRecipient::DEVICE;
+    mojo_parameters->recipient = UsbControlTransferRecipient::DEVICE;
   } else if (parameters.recipient() == "interface") {
     size_t interface_number = parameters.index() & 0xff;
     if (!EnsureInterfaceClaimed(interface_number, resolver))
       return nullptr;
-    mojo_parameters->recipient = usb::ControlTransferRecipient::INTERFACE;
+    mojo_parameters->recipient = UsbControlTransferRecipient::INTERFACE;
   } else if (parameters.recipient() == "endpoint") {
     bool in_transfer = parameters.index() & 0x80;
     size_t endpoint_number = parameters.index() & 0x0f;
     if (!EnsureEndpointAvailable(in_transfer, endpoint_number, resolver))
       return nullptr;
-    mojo_parameters->recipient = usb::ControlTransferRecipient::ENDPOINT;
+    mojo_parameters->recipient = UsbControlTransferRecipient::ENDPOINT;
   } else if (parameters.recipient() == "other") {
-    mojo_parameters->recipient = usb::ControlTransferRecipient::OTHER;
+    mojo_parameters->recipient = UsbControlTransferRecipient::OTHER;
   } else {
     resolver->Reject(DOMException::Create(
         kTypeMismatchError,
         "The control transfer recipient parameter is invalid."));
     return nullptr;
   }
 
   mojo_parameters->request = parameters.request();
   mojo_parameters->value = parameters.value();
   mojo_parameters->index = parameters.index();
   return mojo_parameters;
 }
 
 void USBDevice::SetEndpointsForInterface(size_t interface_index, bool set) {
   const auto& configuration = *Info().configurations[configuration_index_];
   const auto& interface = *configuration.interfaces[interface_index];
   const auto& alternate =
       *interface.alternates[selected_alternates_[interface_index]];
   for (const auto& endpoint : alternate.endpoints) {
     uint8_t endpoint_number = endpoint->endpoint_number;
     if (endpoint_number == 0 || endpoint_number >= 16)
       continue;  // Ignore endpoints with invalid indices.
-    auto& bit_vector = endpoint->direction == usb::TransferDirection::INBOUND
+    auto& bit_vector = endpoint->direction == UsbTransferDirection::INBOUND
                            ? in_endpoints_
                            : out_endpoints_;
     if (set)
       bit_vector.Set(endpoint_number - 1);
     else
       bit_vector.Clear(endpoint_number - 1);
   }
 }
 
 void USBDevice::AsyncOpen(ScriptPromiseResolver* resolver,
-                          usb::OpenDeviceError error) {
+                          UsbOpenDeviceError error) {
   if (!MarkRequestComplete(resolver))
     return;
 
   switch (error) {
-    case usb::OpenDeviceError::ALREADY_OPEN:
+    case UsbOpenDeviceError::ALREADY_OPEN:
       ASSERT_NOT_REACHED();
     // fall through
-    case usb::OpenDeviceError::OK:
+    case UsbOpenDeviceError::OK:
       OnDeviceOpenedOrClosed(true /* opened */);
       resolver->Resolve();
       return;
-    case usb::OpenDeviceError::ACCESS_DENIED:
+    case UsbOpenDeviceError::ACCESS_DENIED:
       OnDeviceOpenedOrClosed(false /* not opened */);
       resolver->Reject(DOMException::Create(kSecurityError, "Access denied."));
       return;
   }
 }
 
 void USBDevice::AsyncClose(ScriptPromiseResolver* resolver) {
   if (!MarkRequestComplete(resolver))
     return;
 
@@ skipping 97 matching lines @@
   interface_state_change_in_progress_.Clear(interface_index);
 
   if (success)
     resolver->Resolve();
   else
     resolver->Reject(
         DOMException::Create(kNetworkError, "Unable to set device interface."));
 }
 
 void USBDevice::AsyncControlTransferIn(ScriptPromiseResolver* resolver,
-                                       usb::TransferStatus status,
+                                       UsbTransferStatus status,
                                        const Optional<Vector<uint8_t>>& data) {
   if (!MarkRequestComplete(resolver))
     return;
 
   DOMException* error = ConvertFatalTransferStatus(status);
   if (error) {
     resolver->Reject(error);
   } else {
     resolver->Resolve(
         USBInTransferResult::Create(ConvertTransferStatus(status), data));
   }
 }
 
 void USBDevice::AsyncControlTransferOut(unsigned transfer_length,
                                         ScriptPromiseResolver* resolver,
-                                        usb::TransferStatus status) {
+                                        UsbTransferStatus status) {
   if (!MarkRequestComplete(resolver))
     return;
 
   DOMException* error = ConvertFatalTransferStatus(status);
   if (error) {
     resolver->Reject(error);
   } else {
     resolver->Resolve(USBOutTransferResult::Create(
         ConvertTransferStatus(status), transfer_length));
   }
 }
 
 void USBDevice::AsyncClearHalt(ScriptPromiseResolver* resolver, bool success) {
   if (!MarkRequestComplete(resolver))
     return;
 
   if (success)
     resolver->Resolve();
   else
     resolver->Reject(
         DOMException::Create(kNetworkError, "Unable to clear endpoint."));
 }
 
 void USBDevice::AsyncTransferIn(ScriptPromiseResolver* resolver,
-                                usb::TransferStatus status,
+                                UsbTransferStatus status,
                                 const Optional<Vector<uint8_t>>& data) {
   if (!MarkRequestComplete(resolver))
     return;
 
   DOMException* error = ConvertFatalTransferStatus(status);
   if (error) {
     resolver->Reject(error);
   } else {
     resolver->Resolve(
         USBInTransferResult::Create(ConvertTransferStatus(status), data));
   }
 }
 
 void USBDevice::AsyncTransferOut(unsigned transfer_length,
                                  ScriptPromiseResolver* resolver,
-                                 usb::TransferStatus status) {
+                                 UsbTransferStatus status) {
   if (!MarkRequestComplete(resolver))
     return;
 
   DOMException* error = ConvertFatalTransferStatus(status);
   if (error) {
     resolver->Reject(error);
   } else {
     resolver->Resolve(USBOutTransferResult::Create(
         ConvertTransferStatus(status), transfer_length));
   }
 }
 
 void USBDevice::AsyncIsochronousTransferIn(
     ScriptPromiseResolver* resolver,
     const Optional<Vector<uint8_t>>& data,
-    Vector<usb::IsochronousPacketPtr> mojo_packets) {
+    Vector<UsbIsochronousPacketPtr> mojo_packets) {
   if (!MarkRequestComplete(resolver))
     return;
 
   DOMArrayBuffer* buffer =
       data ? DOMArrayBuffer::Create(data->Data(), data->size()) : nullptr;
   HeapVector<Member<USBIsochronousInTransferPacket>> packets;
   packets.ReserveCapacity(mojo_packets.size());
   size_t byte_offset = 0;
   for (const auto& packet : mojo_packets) {
     DOMException* error = ConvertFatalTransferStatus(packet->status);
     if (error) {
       resolver->Reject(error);
       return;
     }
     DOMDataView* data_view = nullptr;
     if (buffer) {
       data_view =
           DOMDataView::Create(buffer, byte_offset, packet->transferred_length);
     }
     packets.push_back(USBIsochronousInTransferPacket::Create(
         ConvertTransferStatus(packet->status), data_view));
     byte_offset += packet->length;
   }
   resolver->Resolve(USBIsochronousInTransferResult::Create(buffer, packets));
 }
 
 void USBDevice::AsyncIsochronousTransferOut(
     ScriptPromiseResolver* resolver,
-    Vector<usb::IsochronousPacketPtr> mojo_packets) {
+    Vector<UsbIsochronousPacketPtr> mojo_packets) {
   if (!MarkRequestComplete(resolver))
     return;
 
   HeapVector<Member<USBIsochronousOutTransferPacket>> packets;
   packets.ReserveCapacity(mojo_packets.size());
   for (const auto& packet : mojo_packets) {
     DOMException* error = ConvertFatalTransferStatus(packet->status);
     if (error) {
       resolver->Reject(error);
       return;
@@ skipping 25 matching lines @@
 
 bool USBDevice::MarkRequestComplete(ScriptPromiseResolver* resolver) {
   auto request_entry = device_requests_.Find(resolver);
   if (request_entry == device_requests_.end())
     return false;
   device_requests_.erase(request_entry);
   return true;
 }
 
 }  // namespace blink