Use Mojo enum types in the C++ USB interface

device/usb/usb_device_handle_impl.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 "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <utility>
@@ skipping 17 matching lines @@
 #include "third_party/libusb/src/libusb/libusb.h"
 
 namespace device {
 
 typedef libusb_device* PlatformUsbDevice;
 
 void HandleTransferCompletion(PlatformUsbTransferHandle transfer);
 
 namespace {
 
-uint8_t ConvertTransferDirection(UsbEndpointDirection direction) {
+uint8_t ConvertTransferDirection(UsbTransferDirection direction) {
   switch (direction) {
-    case USB_DIRECTION_INBOUND:
+    case UsbTransferDirection::INBOUND:
       return LIBUSB_ENDPOINT_IN;
-    case USB_DIRECTION_OUTBOUND:
+    case UsbTransferDirection::OUTBOUND:
       return LIBUSB_ENDPOINT_OUT;
-    default:
-      NOTREACHED();
-      return LIBUSB_ENDPOINT_IN;
   }
+  NOTREACHED();
+  return 0;
 }
 
-uint8_t CreateRequestType(UsbEndpointDirection direction,
-                          UsbDeviceHandle::TransferRequestType request_type,
-                          UsbDeviceHandle::TransferRecipient recipient) {
+uint8_t CreateRequestType(UsbTransferDirection direction,
+                          UsbControlTransferType request_type,
+                          UsbControlTransferRecipient recipient) {
   uint8_t result = ConvertTransferDirection(direction);
 
   switch (request_type) {
-    case UsbDeviceHandle::STANDARD:
+    case UsbControlTransferType::STANDARD:
       result |= LIBUSB_REQUEST_TYPE_STANDARD;
       break;
-    case UsbDeviceHandle::CLASS:
+    case UsbControlTransferType::CLASS:
       result |= LIBUSB_REQUEST_TYPE_CLASS;
       break;
-    case UsbDeviceHandle::VENDOR:
+    case UsbControlTransferType::VENDOR:
       result |= LIBUSB_REQUEST_TYPE_VENDOR;
       break;
-    case UsbDeviceHandle::RESERVED:
+    case UsbControlTransferType::RESERVED:
       result |= LIBUSB_REQUEST_TYPE_RESERVED;
       break;
   }
 
   switch (recipient) {
-    case UsbDeviceHandle::DEVICE:
+    case UsbControlTransferRecipient::DEVICE:
       result |= LIBUSB_RECIPIENT_DEVICE;
       break;
-    case UsbDeviceHandle::INTERFACE:
+    case UsbControlTransferRecipient::INTERFACE:
       result |= LIBUSB_RECIPIENT_INTERFACE;
       break;
-    case UsbDeviceHandle::ENDPOINT:
+    case UsbControlTransferRecipient::ENDPOINT:
       result |= LIBUSB_RECIPIENT_ENDPOINT;
       break;
-    case UsbDeviceHandle::OTHER:
+    case UsbControlTransferRecipient::OTHER:
       result |= LIBUSB_RECIPIENT_OTHER;
       break;
   }
 
   return result;
 }
 
 static UsbTransferStatus ConvertTransferStatus(
     const libusb_transfer_status status) {
   switch (status) {
     case LIBUSB_TRANSFER_COMPLETED:
-      return USB_TRANSFER_COMPLETED;
+      return UsbTransferStatus::COMPLETED;
     case LIBUSB_TRANSFER_ERROR:
-      return USB_TRANSFER_ERROR;
+      return UsbTransferStatus::TRANSFER_ERROR;
     case LIBUSB_TRANSFER_TIMED_OUT:
-      return USB_TRANSFER_TIMEOUT;
+      return UsbTransferStatus::TIMEOUT;
     case LIBUSB_TRANSFER_STALL:
-      return USB_TRANSFER_STALLED;
+      return UsbTransferStatus::STALLED;
     case LIBUSB_TRANSFER_NO_DEVICE:
-      return USB_TRANSFER_DISCONNECT;
+      return UsbTransferStatus::DISCONNECT;
     case LIBUSB_TRANSFER_OVERFLOW:
-      return USB_TRANSFER_OVERFLOW;
+      return UsbTransferStatus::BABBLE;
     case LIBUSB_TRANSFER_CANCELLED:
-      return USB_TRANSFER_CANCELLED;
-    default:
-      NOTREACHED();
-      return USB_TRANSFER_ERROR;
+      return UsbTransferStatus::CANCELLED;
   }
+  NOTREACHED();
+  return UsbTransferStatus::TRANSFER_ERROR;
 }
 
 static void RunTransferCallback(
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const UsbDeviceHandle::TransferCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t result) {
   if (callback_task_runner->RunsTasksOnCurrentThread()) {
     callback.Run(status, buffer, result);
@@ skipping 172 matching lines @@
     uint8_t type,
     uint8_t request,
     uint16_t value,
     uint16_t index,
     uint16_t length,
     scoped_refptr<net::IOBuffer> buffer,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
-      device_handle, nullptr, USB_TRANSFER_CONTROL, buffer,
+      device_handle, nullptr, UsbTransferType::CONTROL, buffer,
       length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate control transfer.";
     return nullptr;
   }
 
   libusb_fill_control_setup(reinterpret_cast<uint8_t*>(buffer->data()), type,
                             request, value, index, length);
@@ skipping 11 matching lines @@
 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback));
+      UsbTransferType::BULK, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate bulk transfer.";
     return nullptr;
   }
 
   libusb_fill_bulk_transfer(transfer->platform_transfer_,
                             device_handle->handle_, endpoint,
                             reinterpret_cast<uint8_t*>(buffer->data()), length,
                             &UsbDeviceHandleImpl::Transfer::PlatformCallback,
                             transfer.get(), timeout);
 
   return transfer;
 }
 
 // static
 std::unique_ptr<UsbDeviceHandleImpl::Transfer>
 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     uint8_t endpoint,
     scoped_refptr<net::IOBuffer> buffer,
     int length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback));
+      UsbTransferType::INTERRUPT, buffer, length, callback_task_runner,
+      callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
     USB_LOG(ERROR) << "Failed to allocate interrupt transfer.";
     return nullptr;
   }
 
   libusb_fill_interrupt_transfer(
       transfer->platform_transfer_, device_handle->handle_, endpoint,
       reinterpret_cast<uint8_t*>(buffer->data()), length,
@@ skipping 53 matching lines @@
       callback_(callback) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 UsbDeviceHandleImpl::Transfer::Transfer(
     scoped_refptr<UsbDeviceHandleImpl> device_handle,
     scoped_refptr<InterfaceClaimer> claimed_interface,
     scoped_refptr<net::IOBuffer> buffer,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback)
-    : transfer_type_(USB_TRANSFER_ISOCHRONOUS),
+    : transfer_type_(UsbTransferType::ISOCHRONOUS),
       device_handle_(device_handle),
       buffer_(buffer),
       claimed_interface_(claimed_interface),
       callback_task_runner_(callback_task_runner),
       iso_callback_(callback) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 UsbDeviceHandleImpl::Transfer::~Transfer() {
   if (platform_transfer_) {
     libusb_free_transfer(platform_transfer_);
   }
 }
 
 void UsbDeviceHandleImpl::Transfer::Submit() {
   const int rv = libusb_submit_transfer(platform_transfer_);
   if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to submit transfer: "
                    << ConvertPlatformUsbErrorToString(rv);
-    TransferComplete(USB_TRANSFER_ERROR, 0);
+    TransferComplete(UsbTransferStatus::TRANSFER_ERROR, 0);
   }
 }
 
 void UsbDeviceHandleImpl::Transfer::Cancel() {
   if (!cancelled_) {
     libusb_cancel_transfer(platform_transfer_);
     claimed_interface_ = nullptr;
   }
   cancelled_ = true;
 }
 
 void UsbDeviceHandleImpl::Transfer::ProcessCompletion() {
   DCHECK_GE(platform_transfer_->actual_length, 0)
       << "Negative actual length received";
   size_t actual_length =
       static_cast<size_t>(std::max(platform_transfer_->actual_length, 0));
 
   DCHECK(length_ >= actual_length)
       << "data too big for our buffer (libusb failure?)";
 
   switch (transfer_type_) {
-    case USB_TRANSFER_CONTROL:
+    case UsbTransferType::CONTROL:
       // If the transfer is a control transfer we do not expose the control
       // setup header to the caller. This logic strips off the header if
       // present before invoking the callback provided with the transfer.
       if (actual_length > 0) {
         CHECK(length_ >= LIBUSB_CONTROL_SETUP_SIZE)
             << "buffer was not correctly set: too small for the control header";
 
         if (length_ >= (LIBUSB_CONTROL_SETUP_SIZE + actual_length)) {
           // If the payload is zero bytes long, pad out the allocated buffer
           // size to one byte so that an IOBuffer of that size can be allocated.
           scoped_refptr<net::IOBuffer> resized_buffer = new net::IOBuffer(
               std::max(actual_length, static_cast<size_t>(1)));
           memcpy(resized_buffer->data(),
                  buffer_->data() + LIBUSB_CONTROL_SETUP_SIZE, actual_length);
           buffer_ = resized_buffer;
         }
       }
     // Fall through!
 
-    case USB_TRANSFER_BULK:
-    case USB_TRANSFER_INTERRUPT:
+    case UsbTransferType::BULK:
+    case UsbTransferType::INTERRUPT:
       TransferComplete(ConvertTransferStatus(platform_transfer_->status),
                        actual_length);
       break;
 
-    case USB_TRANSFER_ISOCHRONOUS:
+    case UsbTransferType::ISOCHRONOUS:
       IsochronousTransferComplete();
       break;
 
     default:
       NOTREACHED() << "Invalid usb transfer type";
       break;
   }
 }
 
 /* static */
 void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback(
     PlatformUsbTransferHandle platform_transfer) {
   Transfer* transfer =
       reinterpret_cast<Transfer*>(platform_transfer->user_data);
   DCHECK(transfer->platform_transfer_ == platform_transfer);
   transfer->ProcessCompletion();
 }
 
 void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status,
                                                      size_t bytes_transferred) {
   base::Closure closure;
-  if (transfer_type_ == USB_TRANSFER_ISOCHRONOUS) {
+  if (transfer_type_ == UsbTransferType::ISOCHRONOUS) {
     DCHECK_NE(LIBUSB_TRANSFER_COMPLETED, platform_transfer_->status);
     std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets);
     for (size_t i = 0; i < packets.size(); ++i) {
       packets[i].length = platform_transfer_->iso_packet_desc[i].length;
       packets[i].transferred_length = 0;
       packets[i].status = status;
     }
     closure = base::Bind(iso_callback_, buffer_, packets);
   } else {
     closure = base::Bind(callback_, status, buffer_, bytes_transferred);
@@ skipping 153 matching lines @@
     if (transfer->claimed_interface() == interface_claimer) {
       transfer->Cancel();
     }
   }
 
   blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClearHaltOnBlockingThread,
                             this, endpoint, callback));
 }
 
-void UsbDeviceHandleImpl::ControlTransfer(UsbEndpointDirection direction,
-                                          TransferRequestType request_type,
-                                          TransferRecipient recipient,
+void UsbDeviceHandleImpl::ControlTransfer(UsbTransferDirection direction,
+                                          UsbControlTransferType request_type,
+                                          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) {
   if (task_runner_->BelongsToCurrentThread()) {
     ControlTransferInternal(direction, request_type, recipient, request, value,
                             index, buffer, length, timeout, task_runner_,
                             callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ControlTransferInternal,
                               this, direction, request_type, recipient, request,
                               value, index, buffer, length, timeout,
                               base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(USB_DIRECTION_INBOUND) | endpoint_number;
+      ConvertTransferDirection(UsbTransferDirection::INBOUND) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout,
                                   task_runner_, callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInInternal, this,
                    endpoint_address, packet_lengths, timeout,
                    base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferOut(
     uint8_t endpoint_number,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(USB_DIRECTION_OUTBOUND) | endpoint_number;
+      ConvertTransferDirection(UsbTransferDirection::OUTBOUND) |
+      endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     IsochronousTransferOutInternal(endpoint_address, buffer, packet_lengths,
                                    timeout, task_runner_, callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&UsbDeviceHandleImpl::IsochronousTransferOutInternal, this,
                    endpoint_address, buffer, packet_lengths, timeout,
                    base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
-void UsbDeviceHandleImpl::GenericTransfer(UsbEndpointDirection direction,
+void UsbDeviceHandleImpl::GenericTransfer(UsbTransferDirection direction,
                                           uint8_t endpoint_number,
                                           scoped_refptr<net::IOBuffer> buffer,
                                           size_t length,
                                           unsigned int timeout,
                                           const TransferCallback& callback) {
   uint8_t endpoint_address =
       ConvertTransferDirection(direction) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     GenericTransferInternal(endpoint_address, buffer, length, timeout,
                             task_runner_, callback);
@@ skipping 189 matching lines @@
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(uint8_t endpoint) {
   const auto endpoint_it = endpoint_map_.find(endpoint);
   if (endpoint_it != endpoint_map_.end())
     return claimed_interfaces_[endpoint_it->second.interface->interface_number];
   return nullptr;
 }
 
 void UsbDeviceHandleImpl::ControlTransferInternal(
-    UsbEndpointDirection direction,
-    TransferRequestType request_type,
-    TransferRecipient recipient,
+    UsbTransferDirection direction,
+    UsbControlTransferType request_type,
+    UsbControlTransferRecipient recipient,
     uint8_t request,
     uint16_t value,
     uint16_t index,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::DISCONNECT, buffer, 0);
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<uint16_t>(length)) {
     USB_LOG(USER) << "Transfer too long.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length;
   scoped_refptr<net::IOBuffer> resized_buffer =
       new net::IOBufferWithSize(resized_length);
   if (!resized_buffer.get()) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
   memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(),
          length);
 
   std::unique_ptr<Transfer> transfer = Transfer::CreateControlTransfer(
       this, CreateRequestType(direction, request_type, recipient), request,
       value, index, static_cast<uint16_t>(length), resized_buffer, timeout,
       callback_task_runner, callback);
   if (!transfer) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferInInternal(
     uint8_t endpoint_address,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
-                                   packet_lengths, USB_TRANSFER_DISCONNECT);
+                                   packet_lengths,
+                                   UsbTransferStatus::DISCONNECT);
     return;
   }
 
   size_t length =
       std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length));
   std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       this, endpoint_address, buffer, length, packet_lengths, timeout,
       callback_task_runner, callback);
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::IsochronousTransferOutInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
-                                   packet_lengths, USB_TRANSFER_DISCONNECT);
+                                   packet_lengths,
+                                   UsbTransferStatus::DISCONNECT);
     return;
   }
 
   size_t length =
       std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
   std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer(
       this, endpoint_address, buffer, length, packet_lengths, timeout,
       callback_task_runner, callback);
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::GenericTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int timeout,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::DISCONNECT, buffer, 0);
     return;
   }
 
   const auto endpoint_it = endpoint_map_.find(endpoint_address);
   if (endpoint_it == endpoint_map_.end()) {
     USB_LOG(DEBUG) << "Failed to submit transfer because endpoint "
                    << static_cast<int>(endpoint_address)
                    << " not part of a claimed interface.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<int>(length)) {
     USB_LOG(DEBUG) << "Transfer too long.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   std::unique_ptr<Transfer> transfer;
   UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type;
-  if (transfer_type == USB_TRANSFER_BULK) {
+  if (transfer_type == UsbTransferType::BULK) {
     transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer,
                                             static_cast<int>(length), timeout,
                                             callback_task_runner, callback);
-  } else if (transfer_type == USB_TRANSFER_INTERRUPT) {
+  } else if (transfer_type == UsbTransferType::INTERRUPT) {
     transfer = Transfer::CreateInterruptTransfer(
         this, endpoint_address, buffer, static_cast<int>(length), timeout,
         callback_task_runner, callback);
   } else {
     USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address)
                    << " is not a bulk or interrupt endpoint.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   SubmitTransfer(std::move(transfer));
 }
 
 void UsbDeviceHandleImpl::SubmitTransfer(std::unique_ptr<Transfer> transfer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Transfer is owned by libusb until its completion callback is run. This
@@ skipping 16 matching lines @@
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device