Update USB extension API with suggestions from review.

chrome/browser/extensions/api/usb/usb_api.cc

 // Copyright (c) 2012 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/extensions/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/usb/usb_device_resource.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_service.h"
 #include "chrome/browser/usb/usb_service_factory.h"
 #include "chrome/common/extensions/api/usb.h"
 #include "chrome/common/extensions/permissions/usb_device_permission.h"
 
 namespace BulkTransfer = extensions::api::usb::BulkTransfer;
 namespace ClaimInterface = extensions::api::usb::ClaimInterface;
 namespace CloseDevice = extensions::api::usb::CloseDevice;
 namespace ControlTransfer = extensions::api::usb::ControlTransfer;
 namespace FindDevices = extensions::api::usb::FindDevices;
 namespace InterruptTransfer = extensions::api::usb::InterruptTransfer;
 namespace IsochronousTransfer = extensions::api::usb::IsochronousTransfer;
 namespace ReleaseInterface = extensions::api::usb::ReleaseInterface;
 namespace SetInterfaceAlternateSetting =
     extensions::api::usb::SetInterfaceAlternateSetting;
+namespace usb = extensions::api::usb;
 
-using extensions::api::usb::ControlTransferInfo;
-using extensions::api::usb::Device;
-using extensions::api::usb::GenericTransferInfo;
-using extensions::api::usb::IsochronousTransferInfo;
 using std::string;
 using std::vector;
+using usb::ControlTransferInfo;
+using usb::Device;
+using usb::Direction;
+using usb::GenericTransferInfo;
+using usb::IsochronousTransferInfo;
+using usb::Recipient;
+using usb::RequestType;
 
 namespace {
 
 static const char* kDataKey = "data";
 static const char* kResultCodeKey = "resultCode";
 
-static const char* kDirectionIn = "in";
-static const char* kDirectionOut = "out";
-
-static const char* kRequestTypeClass = "class";
-static const char* kRequestTypeReserved = "reserved";
-static const char* kRequestTypeStandard = "standard";
-static const char* kRequestTypeVendor = "vendor";
-
-static const char* kRecipientDevice = "device";
-static const char* kRecipientEndpoint = "endpoint";
-static const char* kRecipientInterface = "interface";
-static const char* kRecipientOther = "other";
-
 static const char* kErrorCancelled = "Transfer was cancelled.";
 static const char* kErrorDisconnect = "Device disconnected.";
 static const char* kErrorGeneric = "Transfer failed.";
 static const char* kErrorOverflow = "Inbound transfer overflow.";
 static const char* kErrorStalled = "Transfer stalled.";
 static const char* kErrorTimeout = "Transfer timed out.";
 static const char* kErrorTransferLength = "Transfer length is insufficient.";
 
 static const char* kErrorCannotClaimInterface = "Error claiming interface.";
 static const char* kErrorCannotReleaseInterface = "Error releasing interface.";
 static const char* kErrorCannotSetInterfaceAlternateSetting =
     "Error setting alternate interface setting.";
 static const char* kErrorConvertDirection = "Invalid transfer direction.";
 static const char* kErrorConvertRecipient = "Invalid transfer recipient.";
 static const char* kErrorConvertRequestType = "Invalid request type.";
 static const char* kErrorMalformedParameters = "Error parsing parameters.";
 static const char* kErrorNoDevice = "No such device.";
 static const char* kErrorPermissionDenied =
     "Permission to access device was denied";
 
 static UsbDevice* device_for_test_ = NULL;
 
-static bool ConvertDirection(const string& input,
+static bool ConvertDirection(const Direction& input,
                              UsbDevice::TransferDirection* output) {
-  if (input == kDirectionIn) {
-    *output = UsbDevice::INBOUND;
-    return true;
-  } else if (input == kDirectionOut) {
-    *output = UsbDevice::OUTBOUND;
-    return true;
+  switch (input) {
+    case usb::USB_DIRECTION_IN:
+      *output = UsbDevice::INBOUND;
+      return true;
+    case usb::USB_DIRECTION_OUT:
+      *output = UsbDevice::OUTBOUND;
+      return true;
+    default:
+      return false;
   }
+  NOTREACHED();
   return false;
 }
 
-static bool ConvertRequestType(const string& input,
+static bool ConvertRequestType(const RequestType& input,
                                UsbDevice::TransferRequestType* output) {
-  if (input == kRequestTypeStandard) {
-    *output = UsbDevice::STANDARD;
-    return true;
-  } else if (input == kRequestTypeClass) {
-    *output = UsbDevice::CLASS;
-    return true;
-  } else if (input == kRequestTypeVendor) {
-    *output = UsbDevice::VENDOR;
-    return true;
-  } else if (input == kRequestTypeReserved) {
-    *output = UsbDevice::RESERVED;
-    return true;
+  switch (input) {
+    case usb::USB_REQUEST_TYPE_STANDARD:
+      *output = UsbDevice::STANDARD;
+      return true;
+    case usb::USB_REQUEST_TYPE_CLASS:
+      *output = UsbDevice::CLASS;
+      return true;
+    case usb::USB_REQUEST_TYPE_VENDOR:
+      *output = UsbDevice::VENDOR;
+      return true;
+    case usb::USB_REQUEST_TYPE_RESERVED:
+      *output = UsbDevice::RESERVED;
+      return true;
+    default:
+      return false;
   }
+  NOTREACHED();
   return false;
 }
 
-static bool ConvertRecipient(const string& input,
+static bool ConvertRecipient(const Recipient& input,
                              UsbDevice::TransferRecipient* output) {
-  if (input == kRecipientDevice) {
-    *output = UsbDevice::DEVICE;
-    return true;
-  } else if (input == kRecipientInterface) {
-    *output = UsbDevice::INTERFACE;
-    return true;
-  } else if (input == kRecipientEndpoint) {
-    *output = UsbDevice::ENDPOINT;
-    return true;
-  } else if (input == kRecipientOther) {
-    *output = UsbDevice::OTHER;
-    return true;
+  switch (input) {
+    case usb::USB_RECIPIENT_DEVICE:
+      *output = UsbDevice::DEVICE;
+      return true;
+    case usb::USB_RECIPIENT_INTERFACE:
+      *output = UsbDevice::INTERFACE;
+      return true;
+    case usb::USB_RECIPIENT_ENDPOINT:
+      *output = UsbDevice::ENDPOINT;
+      return true;
+    case usb::USB_RECIPIENT_OTHER:
+      *output = UsbDevice::OTHER;
+      return true;
+    default:
+      return false;
   }
+  NOTREACHED();
   return false;
 }
 
 template<class T>
 static bool GetTransferSize(const T& input, size_t* output) {
-  if (input.direction == kDirectionIn) {
+  if (input.direction == usb::USB_DIRECTION_IN) {
     const int* length = input.length.get();
     if (length) {
       *output = *length;
       return true;
     }
-  } else if (input.direction == kDirectionOut) {
+  } else if (input.direction == usb::USB_DIRECTION_OUT) {
     if (input.data.get()) {
       *output = input.data->size();
       return true;
     }
   }
   return false;
 }
 
 template<class T>
 static scoped_refptr<net::IOBuffer> CreateBufferForTransfer(const T& input) {
@@ skipping 99 matching lines @@
                                               scoped_refptr<net::IOBuffer> data,
                                               size_t length) {
   if (status != USB_TRANSFER_COMPLETED)
     SetError(ConvertTransferStatusToErrorString(status));
 
   SetResult(CreateTransferInfo(status, data, length));
   AsyncWorkCompleted();
 }
 
 bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
-    const string& input, UsbDevice::TransferDirection* output) {
+    const Direction& input, UsbDevice::TransferDirection* output) {
   const bool converted = ConvertDirection(input, output);
   if (!converted)
     SetError(kErrorConvertDirection);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRequestTypeSafely(
-    const string& input, UsbDevice::TransferRequestType* output) {
+    const RequestType& input, UsbDevice::TransferRequestType* output) {
   const bool converted = ConvertRequestType(input, output);
   if (!converted)
     SetError(kErrorConvertRequestType);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
-    const string& input, UsbDevice::TransferRecipient* output) {
+    const Recipient& input, UsbDevice::TransferRecipient* output) {
   const bool converted = ConvertRecipient(input, output);
   if (!converted)
     SetError(kErrorConvertRecipient);
   return converted;
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {}
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {}
 
@@ skipping 14 matching lines @@
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(), NULL, device_for_test_);
 
     Device device;
     result->Append(PopulateDevice(manager_->Add(resource), 0, 0));
     SetResult(result.release());
     AsyncWorkCompleted();
     return;
   }
 
-  UsbDevicePermission::CheckParam param(
-      parameters_->vendor_id, parameters_->product_id);
+  const uint16_t vendor_id = parameters_->options.vendor_id;
+  const uint16_t product_id = parameters_->options.product_id;
+  UsbDevicePermission::CheckParam param(vendor_id, product_id);
   if (!GetExtension()->CheckAPIPermissionWithParam(
         APIPermission::kUsbDevice, &param)) {
     LOG(WARNING) << "Insufficient permissions to access device.";
     CompleteWithError(kErrorPermissionDenied);
     return;
   }
 
   UsbService* const service = UsbServiceFactory::GetInstance()->GetForProfile(
       profile());
   if (!service) {
     LOG(WARNING) << "Could not get UsbService for active profile.";
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   vector<scoped_refptr<UsbDevice> > devices;
-  service->FindDevices(parameters_->vendor_id, parameters_->product_id,
-                       &devices);
+  service->FindDevices(vendor_id, product_id, &devices);
   for (size_t i = 0; i < devices.size(); ++i) {
     UsbDevice* const device = devices[i];
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(), NULL, device);
 
     Device js_device;
     result->Append(PopulateDevice(manager_->Add(resource),
-                                  parameters_->vendor_id,
-                                  parameters_->product_id));
+                                  vendor_id,
+                                  product_id));
   }
 
   SetResult(result.release());
   AsyncWorkCompleted();
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {}
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {}
 
@@ skipping 259 matching lines @@
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   device->device()->IsochronousTransfer(direction, generic_transfer.endpoint,
       buffer, size, transfer.packets, transfer.packet_length, 0, base::Bind(
           &UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
 }  // namespace extensions