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

device/usb/mojo/type_converters.h

Index: device/usb/mojo/type_converters.h
diff --git a/device/usb/mojo/type_converters.h b/device/usb/mojo/type_converters.h
index cd4a405a3c5f51112332fee2ab8142253d1e10ab..4cee02ce8f6b5656ad50f9504298b17c0979d7a5 100644
--- a/device/usb/mojo/type_converters.h
+++ b/device/usb/mojo/type_converters.h
@@ -25,48 +25,50 @@ class UsbDevice;
 namespace mojo {
 
 template <>
-struct TypeConverter<device::usb::TransferDirection,
+struct TypeConverter<device::mojom::UsbTransferDirection,
                      device::UsbEndpointDirection> {
-  static device::usb::TransferDirection Convert(
+  static device::mojom::UsbTransferDirection Convert(
       const device::UsbEndpointDirection& direction);
 };
 
 template <>
-struct TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus> {
-  static device::usb::TransferStatus Convert(
+struct TypeConverter<device::mojom::UsbTransferStatus,
+                     device::UsbTransferStatus> {
+  static device::mojom::UsbTransferStatus Convert(
       const device::UsbTransferStatus& status);
 };
 
 template <>
 struct TypeConverter<device::UsbDeviceHandle::TransferRequestType,
-                     device::usb::ControlTransferType> {
+                     device::mojom::UsbControlTransferType> {
   static device::UsbDeviceHandle::TransferRequestType Convert(
-      const device::usb::ControlTransferType& type);
+      const device::mojom::UsbControlTransferType& type);
 };
 
 template <>
 struct TypeConverter<device::UsbDeviceHandle::TransferRecipient,
-                     device::usb::ControlTransferRecipient> {
+                     device::mojom::UsbControlTransferRecipient> {
   static device::UsbDeviceHandle::TransferRecipient Convert(
-      const device::usb::ControlTransferRecipient& recipient);
+      const device::mojom::UsbControlTransferRecipient& recipient);
 };
 
 template <>
-struct TypeConverter<device::usb::EndpointType, device::UsbTransferType> {
-  static device::usb::EndpointType Convert(const device::UsbTransferType& type);
+struct TypeConverter<device::mojom::UsbEndpointType, device::UsbTransferType> {
+  static device::mojom::UsbEndpointType Convert(
+      const device::UsbTransferType& type);
 };
 
 template <>
-struct TypeConverter<device::usb::EndpointInfoPtr,
+struct TypeConverter<device::mojom::UsbEndpointInfoPtr,
                      device::UsbEndpointDescriptor> {
-  static device::usb::EndpointInfoPtr Convert(
+  static device::mojom::UsbEndpointInfoPtr Convert(
       const device::UsbEndpointDescriptor& endpoint);
 };
 
 template <>
-struct TypeConverter<device::usb::AlternateInterfaceInfoPtr,
+struct TypeConverter<device::mojom::UsbAlternateInterfaceInfoPtr,
                      device::UsbInterfaceDescriptor> {
-  static device::usb::AlternateInterfaceInfoPtr Convert(
+  static device::mojom::UsbAlternateInterfaceInfoPtr Convert(
       const device::UsbInterfaceDescriptor& iface);
 };
 
@@ -75,28 +77,29 @@ struct TypeConverter<device::usb::AlternateInterfaceInfoPtr,
 // settings, whereas InterfaceInfos contain their own sets of alternates with
 // a different structure type.
 template <>
-struct TypeConverter<std::vector<device::usb::InterfaceInfoPtr>,
+struct TypeConverter<std::vector<device::mojom::UsbInterfaceInfoPtr>,
                      std::vector<device::UsbInterfaceDescriptor>> {
-  static std::vector<device::usb::InterfaceInfoPtr> Convert(
+  static std::vector<device::mojom::UsbInterfaceInfoPtr> Convert(
       const std::vector<device::UsbInterfaceDescriptor>& interfaces);
 };
 
 template <>
-struct TypeConverter<device::usb::ConfigurationInfoPtr,
+struct TypeConverter<device::mojom::UsbConfigurationInfoPtr,
                      device::UsbConfigDescriptor> {
-  static device::usb::ConfigurationInfoPtr Convert(
+  static device::mojom::UsbConfigurationInfoPtr Convert(
       const device::UsbConfigDescriptor& config);
 };
 
 template <>
-struct TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice> {
-  static device::usb::DeviceInfoPtr Convert(const device::UsbDevice& device);
+struct TypeConverter<device::mojom::UsbDeviceInfoPtr, device::UsbDevice> {
+  static device::mojom::UsbDeviceInfoPtr Convert(
+      const device::UsbDevice& device);
 };
 
 template <>
-struct TypeConverter<device::usb::IsochronousPacketPtr,
+struct TypeConverter<device::mojom::UsbIsochronousPacketPtr,
                      device::UsbDeviceHandle::IsochronousPacket> {
-  static device::usb::IsochronousPacketPtr Convert(
+  static device::mojom::UsbIsochronousPacketPtr Convert(
       const device::UsbDeviceHandle::IsochronousPacket& packet);
 };