Use Mojo enum types in the C++ USB interface

chrome/browser/devtools/device/usb/android_usb_device.cc

 // Copyright 2014 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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 #include <utility>
 
 #include "base/barrier_closure.h"
@@ skipping 18 matching lines @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbInterfaceDescriptor;
 using device::UsbEndpointDescriptor;
 using device::UsbService;
+using device::UsbTransferDirection;
 using device::UsbTransferStatus;
+using device::UsbTransferType;
 
 namespace {
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
@@ skipping 170 matching lines @@
     barrier.Run();
     return;
   }
 
   const UsbInterfaceDescriptor& interface = config->interfaces[interface_id];
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
   for (const UsbEndpointDescriptor& endpoint : interface.endpoints) {
-    if (endpoint.transfer_type != device::USB_TRANSFER_BULK)
+    if (endpoint.transfer_type != UsbTransferType::BULK)
       continue;
-    if (endpoint.direction == device::USB_DIRECTION_INBOUND)
+    if (endpoint.direction == UsbTransferDirection::INBOUND)
       inbound_address = endpoint.address;
     else
       outbound_address = endpoint.address;
     zero_mask = endpoint.maximum_packet_size - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0) {
     barrier.Run();
     return;
   }
@@ skipping 196 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (outgoing_queue_.empty() || !usb_handle_.get())
     return;
 
   BulkMessage message = outgoing_queue_.front();
   outgoing_queue_.pop();
   DumpMessage(true, message->data(), message->size());
 
   usb_handle_->GenericTransfer(
-      device::USB_DIRECTION_OUTBOUND, outbound_address_, message,
+      UsbTransferDirection::OUTBOUND, outbound_address_, message,
       message->size(), kUsbTimeout,
       base::Bind(&AndroidUsbDevice::OutgoingMessageSent,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::OutgoingMessageSent(UsbTransferStatus status,
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t result) {
-  if (status != device::USB_TRANSFER_COMPLETED) {
+  if (status != UsbTransferStatus::COMPLETED) {
     return;
   }
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&AndroidUsbDevice::ProcessOutgoing, this));
 }
 
 void AndroidUsbDevice::ReadHeader() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!usb_handle_.get()) {
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kHeaderSize);
   usb_handle_->GenericTransfer(
-      device::USB_DIRECTION_INBOUND, inbound_address_, buffer, kHeaderSize,
+      UsbTransferDirection::INBOUND, inbound_address_, buffer, kHeaderSize,
       kUsbTimeout,
       base::Bind(&AndroidUsbDevice::ParseHeader, weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::ParseHeader(UsbTransferStatus status,
                                    scoped_refptr<net::IOBuffer> buffer,
                                    size_t result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (status == device::USB_TRANSFER_TIMEOUT) {
+  if (status == UsbTransferStatus::TIMEOUT) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&AndroidUsbDevice::ReadHeader, this));
     return;
   }
 
-  if (status != device::USB_TRANSFER_COMPLETED || result != kHeaderSize) {
+  if (status != UsbTransferStatus::COMPLETED || result != kHeaderSize) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), result);
   std::vector<uint32_t> header(6);
   memcpy(&header[0], buffer->data(), result);
   std::unique_ptr<AdbMessage> message(
       new AdbMessage(header[0], header[1], header[2], ""));
   uint32_t data_length = header[3];
   uint32_t data_check = header[4];
   uint32_t magic = header[5];
   if ((message->command ^ 0xffffffff) != magic) {
-    TransferError(device::USB_TRANSFER_ERROR);
+    TransferError(UsbTransferStatus::TRANSFER_ERROR);
     return;
   }
 
   if (data_length == 0) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                       base::Passed(&message)));
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&AndroidUsbDevice::ReadBody, this,
                               base::Passed(&message), data_length, data_check));
   }
 }
 
 void AndroidUsbDevice::ReadBody(std::unique_ptr<AdbMessage> message,
                                 uint32_t data_length,
                                 uint32_t data_check) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!usb_handle_.get()) {
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::IOBuffer(static_cast<size_t>(data_length));
   usb_handle_->GenericTransfer(
-      device::USB_DIRECTION_INBOUND, inbound_address_, buffer, data_length,
+      UsbTransferDirection::INBOUND, inbound_address_, buffer, data_length,
       kUsbTimeout,
       base::Bind(&AndroidUsbDevice::ParseBody, weak_factory_.GetWeakPtr(),
                  base::Passed(&message), data_length, data_check));
 }
 
 void AndroidUsbDevice::ParseBody(std::unique_ptr<AdbMessage> message,
                                  uint32_t data_length,
                                  uint32_t data_check,
                                  UsbTransferStatus status,
                                  scoped_refptr<net::IOBuffer> buffer,
                                  size_t result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (status == device::USB_TRANSFER_TIMEOUT) {
+  if (status == UsbTransferStatus::TIMEOUT) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&AndroidUsbDevice::ReadBody, this,
                               base::Passed(&message), data_length, data_check));
     return;
   }
 
-  if (status != device::USB_TRANSFER_COMPLETED ||
+  if (status != UsbTransferStatus::COMPLETED ||
       static_cast<uint32_t>(result) != data_length) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), data_length);
   message->body = std::string(buffer->data(), result);
   if (Checksum(message->body) != data_check) {
-    TransferError(device::USB_TRANSFER_ERROR);
+    TransferError(UsbTransferStatus::TRANSFER_ERROR);
     return;
   }
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                     base::Passed(&message)));
 }
 
 void AndroidUsbDevice::HandleIncoming(std::unique_ptr<AdbMessage> message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 89 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32_t socket_id) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   sockets_.erase(socket_id);
 }