Use Mojo enum types in the C++ USB interface

chrome/browser/devtools/device/usb/android_usb_browsertest.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
@@ skipping 19 matching lines @@
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using device::DeviceClient;
 using device::MockUsbService;
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDescriptor;
-using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
 using device::UsbService;
 using device::UsbSynchronizationType;
+using device::UsbTransferDirection;
+using device::UsbTransferStatus;
 using device::UsbTransferType;
 using device::UsbUsageType;
 
 namespace {
 
 struct NoConfigTraits {
   static const int kClass = 0xff;
   static const int kSubclass = 0x42;
   static const int kProtocol = 0x1;
   static const bool kBreaks = false;
@@ skipping 122 matching lines @@
 
   void ResetDevice(const ResultCallback& callback) override {
     NOTIMPLEMENTED();
   }
 
   void ClearHalt(uint8_t endpoint, const ResultCallback& callback) override {
     NOTIMPLEMENTED();
   }
 
   // Async IO. Can be called on any thread.
-  void ControlTransfer(UsbEndpointDirection direction,
-                       TransferRequestType request_type,
-                       TransferRecipient recipient,
+  void ControlTransfer(UsbTransferDirection direction,
+                       device::UsbControlTransferType request_type,
+                       device::UsbControlTransferRecipient recipient,
                        uint8_t request,
                        uint16_t value,
                        uint16_t index,
                        scoped_refptr<net::IOBuffer> buffer,
                        size_t length,
                        unsigned int timeout,
                        const TransferCallback& callback) override {}
 
-  void GenericTransfer(UsbEndpointDirection direction,
+  void GenericTransfer(UsbTransferDirection direction,
                        uint8_t endpoint,
                        scoped_refptr<net::IOBuffer> buffer,
                        size_t length,
                        unsigned int timeout,
                        const TransferCallback& callback) override {
-    if (direction == device::USB_DIRECTION_OUTBOUND) {
+    if (direction == device::UsbTransferDirection::OUTBOUND) {
       if (remaining_body_length_ == 0) {
         std::vector<uint32_t> header(6);
         memcpy(&header[0], buffer->data(), length);
         current_message_.reset(
             new AdbMessage(header[0], header[1], header[2], std::string()));
         remaining_body_length_ = header[3];
         uint32_t magic = header[5];
         if ((current_message_->command ^ 0xffffffff) != magic) {
           DCHECK(false) << "Header checksum error";
           return;
         }
       } else {
         DCHECK(current_message_.get());
         current_message_->body += std::string(buffer->data(), length);
         remaining_body_length_ -= length;
       }
 
       if (remaining_body_length_ == 0) {
         ProcessIncoming();
       }

[mcasas, 2017/04/17 17:15:15]

nit: no need for {} for one-line bodies.

[Reilly Grant (use Gerrit), 2017/04/17 19:20:48]

Since I'm not touching this line in this patch I'd rather not do unrelated
cleanups given this is already a large change.

 
-      device::UsbTransferStatus status =
-          broken_ ? device::USB_TRANSFER_ERROR : device::USB_TRANSFER_COMPLETED;
+      device::UsbTransferStatus status = broken_

[mcasas, 2017/04/17 17:15:15]

micro-nit: const

[Reilly Grant (use Gerrit), 2017/04/17 19:20:48]

I don't like marking local variables const unless there is a compelling reason
to. I don't believe it provides any safety or optimization benefit here.

+                                             ? UsbTransferStatus::TRANSFER_ERROR
+                                             : UsbTransferStatus::COMPLETED;
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, status, nullptr, 0));
       ProcessQueries();
-    } else if (direction == device::USB_DIRECTION_INBOUND) {
+    } else if (direction == device::UsbTransferDirection::INBOUND) {
       queries_.push(Query(callback, buffer, length));
       ProcessQueries();
     }
   }
 
   const UsbInterfaceDescriptor* FindInterfaceByEndpoint(
       uint8_t endpoint_address) {
     NOTIMPLEMENTED();
     return nullptr;
   }
@@ skipping 89 matching lines @@
     }
     ProcessQueries();
   }
 
   void ProcessQueries() {
     if (queries_.empty())
       return;
     Query query = queries_.front();
     if (broken_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(query.callback, device::USB_TRANSFER_ERROR, nullptr, 0));
+          FROM_HERE, base::Bind(query.callback,
+                                UsbTransferStatus::TRANSFER_ERROR, nullptr, 0));
     }
 
     if (query.size > output_buffer_.size())
       return;
 
     queries_.pop();
     std::copy(output_buffer_.begin(),
               output_buffer_.begin() + query.size,
               query.buffer->data());
     output_buffer_.erase(output_buffer_.begin(),
                          output_buffer_.begin() + query.size);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(query.callback, device::USB_TRANSFER_COMPLETED,
+        FROM_HERE, base::Bind(query.callback, UsbTransferStatus::COMPLETED,
                               query.buffer, query.size));
   }
 
   void IsochronousTransferIn(
       uint8_t endpoint_number,
       const std::vector<uint32_t>& packet_lengths,
       unsigned int timeout,
       const IsochronousTransferCallback& callback) override {}
 
   void IsochronousTransferOut(
@@ skipping 398 matching lines @@
   EXPECT_EQ(2, listener.invoked_);
   EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_);
   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 }
 
 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) {
   MockCountListenerForCheckingTraits listener(adb_bridge_);
   adb_bridge_->AddDeviceCountListener(&listener);
   runner_->Run();
 }