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

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

 // 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.
 
 #ifndef USBDevice_h
 #define USBDevice_h
 
 #include "bindings/core/v8/ArrayBufferOrArrayBufferView.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptWrappable.h"
@@ skipping 10 matching lines @@
 class USBConfiguration;
 class USBControlTransferParameters;
 
 class USBDevice : public GarbageCollectedFinalized<USBDevice>,
                   public ContextLifecycleObserver,
                   public ScriptWrappable {
   USING_GARBAGE_COLLECTED_MIXIN(USBDevice);
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static USBDevice* Create(device::usb::blink::DeviceInfoPtr device_info,
-                           device::usb::blink::DevicePtr device,
+  static USBDevice* Create(device::mojom::blink::UsbDeviceInfoPtr device_info,
+                           device::mojom::blink::UsbDevicePtr device,
                            ExecutionContext* context) {
     return new USBDevice(std::move(device_info), std::move(device), context);
   }
 
-  explicit USBDevice(device::usb::blink::DeviceInfoPtr,
-                     device::usb::blink::DevicePtr,
+  explicit USBDevice(device::mojom::blink::UsbDeviceInfoPtr,
+                     device::mojom::blink::UsbDevicePtr,
                      ExecutionContext*);
   virtual ~USBDevice();
 
-  const device::usb::blink::DeviceInfo& Info() const { return *device_info_; }
+  const device::mojom::blink::UsbDeviceInfo& Info() const {
+    return *device_info_;
+  }
   bool IsInterfaceClaimed(size_t configuration_index,
                           size_t interface_index) const;
   size_t SelectedAlternateInterface(size_t interface_index) const;
 
   // USBDevice.idl
   uint8_t usbVersionMajor() const { return Info().usb_version_major; }
   uint8_t usbVersionMinor() const { return Info().usb_version_minor; }
   uint8_t usbVersionSubminor() const { return Info().usb_version_subminor; }
   uint8_t deviceClass() const { return Info().class_code; }
   uint8_t deviceSubclass() const { return Info().subclass_code; }
@@ skipping 57 matching lines @@
   int FindAlternateIndex(size_t interface_index,
                          uint8_t alternate_setting) const;
   bool EnsureNoDeviceOrInterfaceChangeInProgress(ScriptPromiseResolver*) const;
   bool EnsureDeviceConfigured(ScriptPromiseResolver*) const;
   bool EnsureInterfaceClaimed(uint8_t interface_number,
                               ScriptPromiseResolver*) const;
   bool EnsureEndpointAvailable(bool in_transfer,
                                uint8_t endpoint_number,
                                ScriptPromiseResolver*) const;
   bool AnyInterfaceChangeInProgress() const;
-  device::usb::blink::ControlTransferParamsPtr ConvertControlTransferParameters(
-      const USBControlTransferParameters&,
-      ScriptPromiseResolver*) const;
+  device::mojom::blink::UsbControlTransferParamsPtr
+  ConvertControlTransferParameters(const USBControlTransferParameters&,
+                                   ScriptPromiseResolver*) const;
   void SetEndpointsForInterface(size_t interface_index, bool set);
 
-  void AsyncOpen(ScriptPromiseResolver*, device::usb::blink::OpenDeviceError);
+  void AsyncOpen(ScriptPromiseResolver*,
+                 device::mojom::blink::UsbOpenDeviceError);
   void AsyncClose(ScriptPromiseResolver*);
   void OnDeviceOpenedOrClosed(bool);
   void AsyncSelectConfiguration(size_t configuration_index,
                                 ScriptPromiseResolver*,
                                 bool success);
   void OnConfigurationSelected(bool success, size_t configuration_index);
   void AsyncClaimInterface(size_t interface_index,
                            ScriptPromiseResolver*,
                            bool success);
   void AsyncReleaseInterface(size_t interface_index,
                              ScriptPromiseResolver*,
                              bool success);
   void OnInterfaceClaimedOrUnclaimed(bool claimed, size_t interface_index);
   void AsyncSelectAlternateInterface(size_t interface_index,
                                      size_t alternate_index,
                                      ScriptPromiseResolver*,
                                      bool success);
   void AsyncControlTransferIn(ScriptPromiseResolver*,
-                              device::usb::blink::TransferStatus,
+                              device::mojom::blink::UsbTransferStatus,
                               const Optional<Vector<uint8_t>>&);
   void AsyncControlTransferOut(unsigned,
                                ScriptPromiseResolver*,
-                               device::usb::blink::TransferStatus);
+                               device::mojom::blink::UsbTransferStatus);
   void AsyncClearHalt(ScriptPromiseResolver*, bool success);
   void AsyncTransferIn(ScriptPromiseResolver*,
-                       device::usb::blink::TransferStatus,
+                       device::mojom::blink::UsbTransferStatus,
                        const Optional<Vector<uint8_t>>&);
   void AsyncTransferOut(unsigned,
                         ScriptPromiseResolver*,
-                        device::usb::blink::TransferStatus);
+                        device::mojom::blink::UsbTransferStatus);
   void AsyncIsochronousTransferIn(
       ScriptPromiseResolver*,
       const Optional<Vector<uint8_t>>&,
-      Vector<device::usb::blink::IsochronousPacketPtr>);
+      Vector<device::mojom::blink::UsbIsochronousPacketPtr>);
   void AsyncIsochronousTransferOut(
       ScriptPromiseResolver*,
-      Vector<device::usb::blink::IsochronousPacketPtr>);
+      Vector<device::mojom::blink::UsbIsochronousPacketPtr>);
   void AsyncReset(ScriptPromiseResolver*, bool success);
 
   void OnConnectionError();
   bool MarkRequestComplete(ScriptPromiseResolver*);
 
-  device::usb::blink::DeviceInfoPtr device_info_;
-  device::usb::blink::DevicePtr device_;
+  device::mojom::blink::UsbDeviceInfoPtr device_info_;
+  device::mojom::blink::UsbDevicePtr device_;
   HeapHashSet<Member<ScriptPromiseResolver>> device_requests_;
   bool opened_;
   bool device_state_change_in_progress_;
   int configuration_index_;
   WTF::BitVector claimed_interfaces_;
   WTF::BitVector interface_state_change_in_progress_;
   WTF::Vector<size_t> selected_alternates_;
   WTF::BitVector in_endpoints_;
   WTF::BitVector out_endpoints_;
 };
 
 }  // namespace blink
 
 #endif  // USBDevice_h