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

device/usb/public/interfaces/device.mojom

 // 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.
 
-module device.usb;
+module device.mojom;
 
-enum OpenDeviceError {
+enum UsbOpenDeviceError {
   // Opening the device succeeded.
   OK,
 
   // The operating system denied access to the device.
   ACCESS_DENIED,
 
   // The device is already open.
   ALREADY_OPEN,
 };
 
-enum TransferDirection {
+enum UsbTransferDirection {
   INBOUND,
   OUTBOUND,
 };
 
-enum ControlTransferType {
+enum UsbControlTransferType {
   STANDARD,
   CLASS,
   VENDOR,
   RESERVED
 };
 
-enum ControlTransferRecipient {
+enum UsbControlTransferRecipient {
   DEVICE,
   INTERFACE,
   ENDPOINT,
   OTHER
 };
 
-enum EndpointType {
+enum UsbEndpointType {
   BULK,
   INTERRUPT,
   ISOCHRONOUS,
 };
 
-struct EndpointInfo {
+struct UsbEndpointInfo {
   uint8 endpoint_number;
-  TransferDirection direction;
-  EndpointType type;
+  UsbTransferDirection direction;
+  UsbEndpointType type;
   uint32 packet_size;
 };
 
-struct AlternateInterfaceInfo {
+struct UsbAlternateInterfaceInfo {
   uint8 alternate_setting;
   uint8 class_code;
   uint8 subclass_code;
   uint8 protocol_code;
   string? interface_name;
-  array<EndpointInfo> endpoints;
+  array<UsbEndpointInfo> endpoints;
 };
 
-struct InterfaceInfo {
+struct UsbInterfaceInfo {
   uint8 interface_number;
-  array<AlternateInterfaceInfo> alternates;
+  array<UsbAlternateInterfaceInfo> alternates;
 };
 
-struct ConfigurationInfo {
+struct UsbConfigurationInfo {
   uint8 configuration_value;
   string? configuration_name;
-  array<InterfaceInfo> interfaces;
+  array<UsbInterfaceInfo> interfaces;
 };
 
-struct DeviceInfo {
+struct UsbDeviceInfo {
   string guid;
   uint8 usb_version_major;
   uint8 usb_version_minor;
   uint8 usb_version_subminor;
   uint8 class_code;
   uint8 subclass_code;
   uint8 protocol_code;
   uint16 vendor_id;
   uint16 product_id;
   uint8 device_version_major;
   uint8 device_version_minor;
   uint8 device_version_subminor;
   string? manufacturer_name;
   string? product_name;
   string? serial_number;
   uint8 active_configuration;
-  array<ConfigurationInfo> configurations;
+  array<UsbConfigurationInfo> configurations;
 };
 
-struct ControlTransferParams {
-  ControlTransferType type;
-  ControlTransferRecipient recipient;
+struct UsbControlTransferParams {
+  UsbControlTransferType type;
+  UsbControlTransferRecipient recipient;
   uint8 request;
   uint16 value;
   uint16 index;
 };
 
-enum TransferStatus {
+enum UsbTransferStatus {
   // The transfer completed successfully.
   COMPLETED,
 
   // The transfer failed due to a non-specific error.
   TRANSFER_ERROR,
 
   // The transfer was not allowed.
   PERMISSION_DENIED,
 
   // The transfer timed out.
@@ skipping 10 matching lines @@
 
   // The transfer succeeded, but the device sent more data than was requested.
   // This applies only to inbound transfers.
   BABBLE,
 
   // The transfer succeeded, but the device sent less data than was requested.
   // This applies only to inbound transfers.
   SHORT_PACKET,
 };
 
-struct IsochronousPacket {
+struct UsbIsochronousPacket {
   uint32 length;
   uint32 transferred_length;
-  TransferStatus status;
+  UsbTransferStatus status;
 };
 
-interface Device {
+interface UsbDevice {
   // Opens the device. Methods below require the device be opened first.
-  Open() => (OpenDeviceError error);
+  Open() => (UsbOpenDeviceError error);
 
   // Closes the device.
   Close() => ();
 
   // Initiates a device control transfer to set the device's configuration to
   // one with the configuration value |value|.
   SetConfiguration(uint8 value) => (bool success);
 
   // Claims a single interface in the current device configuration.
   ClaimInterface(uint8 interface_number) => (bool success);
@@ skipping 15 matching lines @@
   // details of the request. Transfers to recipients other than DEVICE require a
   // corresponding interface to be claimed.
   //
   // |length| specifies the expected number of bytes to receive for this
   // transfer. The size of |data| will never exceed |length|, and |data| will be
   // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
-  ControlTransferIn(ControlTransferParams params, uint32 length, uint32 timeout)
-      => (TransferStatus status, array<uint8>? data);
+  ControlTransferIn(UsbControlTransferParams params,
+                    uint32 length,
+                    uint32 timeout)
+      => (UsbTransferStatus status, array<uint8>? data);
 
   // Initiates an inbound control transfer request. |params| determine the
   // details of the request. Transfers to recipients other than DEVICE require a
   // corresponding interface to be claimed.
   //
   // |data| specifies the bytes to send the device in the body of the request.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
-  ControlTransferOut(ControlTransferParams params,
+  ControlTransferOut(UsbControlTransferParams params,
                      array<uint8> data,
                      uint32 timeout)
-      => (TransferStatus status);
+      => (UsbTransferStatus status);
 
   // Initiates an inbound generic transfer request on a specific endpoint. The
   // interface to which |endpoint_number| belongs must be claimed, and the
   // appropriate alternate setting must be set on that interface before
   // transfers can be initiated on the endpoint. The endpoint must be of type
   // BULK or INTERRUPT.
   //
   // |length| specifies the expected number of bytes to receive for this
   // transfer. The size of |data| will never exceed |length|, and |data| will be
   // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
   GenericTransferIn(uint8 endpoint_number, uint32 length, uint32 timeout)
-      => (TransferStatus status, array<uint8>? data);
+      => (UsbTransferStatus status, array<uint8>? data);
 
   // Initiates an outbound generic transfer request on a specific endpoint. The
   // interface to which |endpoint_number| belongs must be claimed, and the
   // appropriate alternate setting must be set on that interface before
   // transfers can be initiated on the endpoint. The endpoint must be of type
   // BULK or INTERRUPT.
   //
   // |data| specifies the bytes to send the device in the body of the request.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
   GenericTransferOut(uint8 endpoint_number, array<uint8> data, uint32 timeout)
-      => (TransferStatus status);
+      => (UsbTransferStatus status);
 
   // Initiates an inbound isochronous transfer request on a specific endpoint.
   // The interface to which |endpoint_number| belongs must be claimed, and the
   // appropriate alternate setting must be set on that interface before
   // transfers can be initiated on the endpoint. The endpoint must be of type
   // ISOCHRONOUS.
   //
   // |packet_lengths| specifies the maximum expected number of bytes to receive
   // for each packet in this transfer.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
   //
   // |data| contains the data received from the device, if any. |packets|
   // contains the status of each packet received from the device, in order. The
   // length of the packet indicates its position in |data| while it's
   // transferred length gives the amount of data actually received from the
   // device.
   IsochronousTransferIn(uint8 endpoint_number,
                         array<uint32> packet_lengths,
                         uint32 timeout)
-      => (array<uint8>? data, array<IsochronousPacket> packets);
+      => (array<uint8>? data, array<UsbIsochronousPacket> packets);
 
   // Initiates an outbound isochronous transfer request on a specific endpoint.
   // The interface to which |endpoint_number| belongs must be claimed, and the
   // appropriate alternate setting must be set on that interface before
   // transfers can be initiated on the endpoint. The endpoint must be of type
   // ISOCHRONOUS.
   //
   // |data| specifies the bytes to send to the device.
   //
   // |packet_lengths| specifies how |data| should be separated into packets when
   // it is sent to the device.
   //
   // |timeout| specifies the request timeout in milliseconds. A timeout of 0
   // indicates no timeout: the request will remain pending indefinitely until
   // completed or otherwise terminated.
 
   // |packets| contains the status of each packet sent to the device, in order.
   IsochronousTransferOut(uint8 endpoint_number,
                          array<uint8> data,
                          array<uint32> packet_lengths,
                          uint32 timeout)
-      => (array<IsochronousPacket> packets);
+      => (array<UsbIsochronousPacket> packets);
 };