Move chrome.usb to //extensions

extensions/browser/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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "chrome/browser/extensions/api/usb/usb_device_resource.h"
-#include "chrome/common/extensions/api/usb.h"
 #include "components/usb_service/usb_device_handle.h"
 #include "components/usb_service/usb_service.h"
+#include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/common/api/usb.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
-namespace usb = extensions::api::usb;
+namespace usb = extensions::core_api::usb;
 namespace BulkTransfer = usb::BulkTransfer;
 namespace ClaimInterface = usb::ClaimInterface;
 namespace CloseDevice = usb::CloseDevice;
 namespace ControlTransfer = usb::ControlTransfer;
 namespace FindDevices = usb::FindDevices;
 namespace GetDevices = usb::GetDevices;
 namespace InterruptTransfer = usb::InterruptTransfer;
 namespace IsochronousTransfer = usb::IsochronousTransfer;
 namespace ListInterfaces = usb::ListInterfaces;
 namespace OpenDevice = usb::OpenDevice;
@@ skipping 59 matching lines @@
 const char kErrorCannotSetInterfaceAlternateSetting[] =
     "Error setting alternate interface setting.";
 const char kErrorConvertDirection[] = "Invalid transfer direction.";
 const char kErrorConvertRecipient[] = "Invalid transfer recipient.";
 const char kErrorConvertRequestType[] = "Invalid request type.";
 const char kErrorConvertSynchronizationType[] = "Invalid synchronization type";
 const char kErrorConvertTransferType[] = "Invalid endpoint type.";
 const char kErrorConvertUsageType[] = "Invalid usage type.";
 const char kErrorMalformedParameters[] = "Error parsing parameters.";
 const char kErrorNoDevice[] = "No such device.";
-const char kErrorPermissionDenied[] =
-    "Permission to access device was denied";
+const char kErrorPermissionDenied[] = "Permission to access device was denied";
 const char kErrorInvalidTransferLength[] =
     "Transfer length must be a positive number less than 104,857,600.";
 const char kErrorInvalidNumberOfPackets[] =
     "Number of packets must be a positive number less than 4,194,304.";
-const char kErrorInvalidPacketLength[] = "Packet length must be a "
-    "positive number less than 65,536.";
+const char kErrorInvalidPacketLength[] =
+    "Packet length must be a positive number less than 65,536.";
 const char kErrorResetDevice[] =
     "Error resetting the device. The device has been closed.";
 
 const size_t kMaxTransferLength = 100 * 1024 * 1024;
 const int kMaxPackets = 4 * 1024 * 1024;
 const int kMaxPacketLength = 64 * 1024;
 
 bool ConvertDirectionToApi(const UsbEndpointDirection& input,
                            Direction* output) {
   switch (input) {
@@ skipping 23 matching lines @@
       return true;
     case usb_service::USB_SYNCHRONIZATION_SYNCHRONOUS:
       *output = usb::SYNCHRONIZATION_TYPE_SYNCHRONOUS;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-bool ConvertTransferTypeToApi(
-    const UsbTransferType& input,
-    usb::TransferType* output) {
+bool ConvertTransferTypeToApi(const UsbTransferType& input,
+                              usb::TransferType* output) {
   switch (input) {
     case usb_service::USB_TRANSFER_CONTROL:
       *output = usb::TRANSFER_TYPE_CONTROL;
       return true;
     case usb_service::USB_TRANSFER_INTERRUPT:
       *output = usb::TRANSFER_TYPE_INTERRUPT;
       return true;
     case usb_service::USB_TRANSFER_ISOCHRONOUS:
       *output = usb::TRANSFER_TYPE_ISOCHRONOUS;
       return true;
@@ skipping 16 matching lines @@
       return true;
     case usb_service::USB_USAGE_EXPLICIT_FEEDBACK:
       *output = usb::USAGE_TYPE_EXPLICITFEEDBACK;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-bool ConvertDirection(const Direction& input,
-                      UsbEndpointDirection* output) {
+bool ConvertDirection(const Direction& input, UsbEndpointDirection* output) {
   switch (input) {
     case usb::DIRECTION_IN:
       *output = usb_service::USB_DIRECTION_INBOUND;
       return true;
     case usb::DIRECTION_OUT:
       *output = usb_service::USB_DIRECTION_OUTBOUND;
       return true;
     default:
       NOTREACHED();
       return false;
@@ skipping 35 matching lines @@
       return true;
     case usb::RECIPIENT_OTHER:
       *output = UsbDeviceHandle::OTHER;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-template<class T>
+template <class T>
 bool GetTransferSize(const T& input, size_t* output) {
   if (input.direction == usb::DIRECTION_IN) {
     const int* length = input.length.get();
     if (length && *length >= 0 &&
         static_cast<size_t>(*length) < kMaxTransferLength) {
       *output = *length;
       return true;
     }
   } else if (input.direction == usb::DIRECTION_OUT) {
     if (input.data.get()) {
       *output = input.data->size();
       return true;
     }
   }
   return false;
 }
 
-template<class T>
+template <class T>
 scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
-    const T& input, UsbEndpointDirection direction, size_t size) {
-
+    const T& input,
+    UsbEndpointDirection direction,
+    size_t size) {
   if (size >= kMaxTransferLength)
     return NULL;
 
   // Allocate a |size|-bytes buffer, or a one-byte buffer if |size| is 0. This
   // is due to an impedance mismatch between IOBuffer and URBs. An IOBuffer
   // cannot represent a zero-length buffer, while an URB can.
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(std::max(
-      static_cast<size_t>(1), size));
+  scoped_refptr<net::IOBuffer> buffer =
+      new net::IOBuffer(std::max(static_cast<size_t>(1), size));
 
   if (direction == usb_service::USB_DIRECTION_INBOUND) {
     return buffer;
   } else if (direction == usb_service::USB_DIRECTION_OUTBOUND) {
     if (input.data.get() && size <= input.data->size()) {
       memcpy(buffer->data(), input.data->data(), size);
       return buffer;
     }
   }
   NOTREACHED();
@@ skipping 33 matching lines @@
     bool success) {
   if (success) {
     ++i;
   } else {
     i = devices->erase(i);
   }
   if (i == devices->end()) {
     callback.Run(devices.Pass());
     return;
   }
-  (*i)->RequestUsbAcess(interface_id, base::Bind(RequestUsbDevicesAccessHelper,
-                                                 base::Passed(devices.Pass()),
-                                                 i, interface_id, callback));
+  (*i)->RequestUsbAcess(interface_id,
+                        base::Bind(RequestUsbDevicesAccessHelper,
+                                   base::Passed(devices.Pass()),
+                                   i,
+                                   interface_id,
+                                   callback));
 }
 
 void RequestUsbDevicesAccess(
     ScopedDeviceVector devices,
     int interface_id,
     const base::Callback<void(ScopedDeviceVector result)>& callback) {
   if (devices->empty()) {
     callback.Run(devices.Pass());
     return;
   }
   std::vector<scoped_refptr<UsbDevice> >::iterator i = devices->begin();
-  (*i)->RequestUsbAcess(
-      interface_id,
-      base::Bind(RequestUsbDevicesAccessHelper, base::Passed(devices.Pass()),
-                 i, interface_id, callback));
+  (*i)->RequestUsbAcess(interface_id,
+                        base::Bind(RequestUsbDevicesAccessHelper,
+                                   base::Passed(devices.Pass()),
+                                   i,
+                                   interface_id,
+                                   callback));
 }
 #endif  // OS_CHROMEOS
 
-base::DictionaryValue* CreateTransferInfo(
-    UsbTransferStatus status,
-    scoped_refptr<net::IOBuffer> data,
-    size_t length) {
+base::DictionaryValue* CreateTransferInfo(UsbTransferStatus status,
+                                          scoped_refptr<net::IOBuffer> data,
+                                          size_t length) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, status);
-  result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(data->data(),
-                                                                  length));
+  result->Set(kDataKey,
+              base::BinaryValue::CreateWithCopiedBuffer(data->data(), length));
   return result;
 }
 
-base::Value* PopulateConnectionHandle(int handle, int vendor_id,
+base::Value* PopulateConnectionHandle(int handle,
+                                      int vendor_id,
                                       int product_id) {
   ConnectionHandle result;
   result.handle = handle;
   result.vendor_id = vendor_id;
   result.product_id = product_id;
   return result.ToValue().release();
 }
 
 base::Value* PopulateDevice(UsbDevice* device) {
   Device result;
@@ skipping 17 matching lines @@
   descriptor.interface_subclass = interface_subclass;
   descriptor.interface_protocol = interface_protocol;
   descriptor.endpoints = *endpoints;
   return descriptor.ToValue().release();
 }
 
 }  // namespace
 
 namespace extensions {
 
-UsbAsyncApiFunction::UsbAsyncApiFunction()
-    : manager_(NULL) {
+UsbAsyncApiFunction::UsbAsyncApiFunction() : manager_(NULL) {
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 }
 
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   set_work_thread_id(BrowserThread::FILE);
   return manager_ != NULL;
 }
 
 bool UsbAsyncApiFunction::Respond() {
   return error_.empty();
 }
 
-scoped_refptr<UsbDevice>
-UsbAsyncApiFunction::GetDeviceOrOrCompleteWithError(
+scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrOrCompleteWithError(
     const Device& input_device) {
   const uint16_t vendor_id = input_device.vendor_id;
   const uint16_t product_id = input_device.product_id;
   UsbDevicePermission::CheckParam param(
       vendor_id, product_id, UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(), APIPermission::kUsbDevice, &param)) {
     LOG(WARNING) << "Insufficient permissions to access device.";
     CompleteWithError(kErrorPermissionDenied);
     return NULL;
@@ skipping 53 matching lines @@
 
 void UsbAsyncApiFunction::RemoveUsbDeviceResource(int api_resource_id) {
   manager_->Remove(extension_->id(), api_resource_id);
 }
 
 void UsbAsyncApiFunction::CompleteWithError(const std::string& error) {
   SetError(error);
   AsyncWorkCompleted();
 }
 
-UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {}
+UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {
+}
 
-UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {}
+UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {
+}
 
 void UsbAsyncApiTransferFunction::OnCompleted(UsbTransferStatus status,
                                               scoped_refptr<net::IOBuffer> data,
                                               size_t length) {
   if (status != usb_service::USB_TRANSFER_COMPLETED)
     SetError(ConvertTransferStatusToErrorString(status));
 
   SetResult(CreateTransferInfo(status, data, length));
   AsyncWorkCompleted();
 }
 
 bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
-    const Direction& input, UsbEndpointDirection* output) {
+    const Direction& input,
+    UsbEndpointDirection* output) {
   const bool converted = ConvertDirection(input, output);
   if (!converted)
     SetError(kErrorConvertDirection);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRequestTypeSafely(
-    const RequestType& input, UsbDeviceHandle::TransferRequestType* output) {
+    const RequestType& input,
+    UsbDeviceHandle::TransferRequestType* output) {
   const bool converted = ConvertRequestType(input, output);
   if (!converted)
     SetError(kErrorConvertRequestType);
   return converted;
 }
 
 bool UsbAsyncApiTransferFunction::ConvertRecipientSafely(
-    const Recipient& input, UsbDeviceHandle::TransferRecipient* output) {
+    const Recipient& input,
+    UsbDeviceHandle::TransferRecipient* output) {
   const bool converted = ConvertRecipient(input, output);
   if (!converted)
     SetError(kErrorConvertRecipient);
   return converted;
 }
 
-UsbFindDevicesFunction::UsbFindDevicesFunction() {}
+UsbFindDevicesFunction::UsbFindDevicesFunction() {
+}
 
-UsbFindDevicesFunction::~UsbFindDevicesFunction() {}
+UsbFindDevicesFunction::~UsbFindDevicesFunction() {
+}
 
 bool UsbFindDevicesFunction::Prepare() {
   parameters_ = FindDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbFindDevicesFunction::AsyncWorkStart() {
   scoped_ptr<base::ListValue> result(new base::ListValue());
-
   const uint16_t vendor_id = parameters_->options.vendor_id;
   const uint16_t product_id = parameters_->options.product_id;
-  int interface_id = parameters_->options.interface_id.get() ?
-      *parameters_->options.interface_id.get() :
-      UsbDevicePermissionData::ANY_INTERFACE;
+  int interface_id = parameters_->options.interface_id.get()
+                         ? *parameters_->options.interface_id.get()
+                         : UsbDevicePermissionData::ANY_INTERFACE;
   UsbDevicePermission::CheckParam param(vendor_id, product_id, interface_id);
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(), APIPermission::kUsbDevice, &param)) {
     LOG(WARNING) << "Insufficient permissions to access device.";
     CompleteWithError(kErrorPermissionDenied);
     return;
   }
 
-  UsbService *service = UsbService::GetInstance();
+  UsbService* service = UsbService::GetInstance();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return;
   }
 
   ScopedDeviceVector devices(new DeviceVector());
   service->GetDevices(devices.get());
 
-  for (DeviceVector::iterator it = devices->begin();
-      it != devices->end();) {
+  for (DeviceVector::iterator it = devices->begin(); it != devices->end();) {
     if ((*it)->vendor_id() != vendor_id || (*it)->product_id() != product_id) {
       it = devices->erase(it);
     } else {
       ++it;
     }
   }
 
 #if defined(OS_CHROMEOS)
   RequestUsbDevicesAccess(
-      devices.Pass(), interface_id,
+      devices.Pass(),
+      interface_id,
       base::Bind(&UsbFindDevicesFunction::OpenDevices, this));
 #else
   OpenDevices(devices.Pass());
 #endif  // OS_CHROMEOS
 }
 
 void UsbFindDevicesFunction::OpenDevices(ScopedDeviceVector devices) {
   base::ListValue* result = new base::ListValue();
 
   for (size_t i = 0; i < devices->size(); ++i) {
-    scoped_refptr<UsbDeviceHandle> device_handle =
-      devices->at(i)->Open();
+    scoped_refptr<UsbDeviceHandle> device_handle = devices->at(i)->Open();
     if (device_handle)
       device_handles_.push_back(device_handle);
   }
 
   for (size_t i = 0; i < device_handles_.size(); ++i) {
     UsbDeviceHandle* const device_handle = device_handles_[i].get();
     UsbDeviceResource* const resource =
         new UsbDeviceResource(extension_->id(), device_handle);
 
     result->Append(PopulateConnectionHandle(manager_->Add(resource),
-                                             parameters_->options.vendor_id,
-                                             parameters_->options.product_id));
+                                            parameters_->options.vendor_id,
+                                            parameters_->options.product_id));
   }
 
   SetResult(result);
   AsyncWorkCompleted();
 }
 
 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 }
 
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
@@ skipping 37 matching lines @@
   }
 
   for (size_t i = 0; i < devices.size(); ++i) {
     result->Append(PopulateDevice(devices[i].get()));
   }
 
   SetResult(result.release());
   AsyncWorkCompleted();
 }
 
-UsbRequestAccessFunction::UsbRequestAccessFunction() {}
+UsbRequestAccessFunction::UsbRequestAccessFunction() {
+}
 
-UsbRequestAccessFunction::~UsbRequestAccessFunction() {}
+UsbRequestAccessFunction::~UsbRequestAccessFunction() {
+}
 
 bool UsbRequestAccessFunction::Prepare() {
   parameters_ = RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbRequestAccessFunction::AsyncWorkStart() {
 #if defined(OS_CHROMEOS)
   scoped_refptr<UsbDevice> device =
       GetDeviceOrOrCompleteWithError(parameters_->device);
-  if (!device) return;
+  if (!device)
+    return;
 
-  device->RequestUsbAcess(parameters_->interface_id,
-                          base::Bind(&UsbRequestAccessFunction::OnCompleted,
-                                     this));
+  device->RequestUsbAcess(
+      parameters_->interface_id,
+      base::Bind(&UsbRequestAccessFunction::OnCompleted, this));
 #else
   SetResult(new base::FundamentalValue(false));
   CompleteWithError(kErrorNotSupported);
 #endif  // OS_CHROMEOS
 }
 
 void UsbRequestAccessFunction::OnCompleted(bool success) {
   SetResult(new base::FundamentalValue(success));
   AsyncWorkCompleted();
 }
 
-UsbOpenDeviceFunction::UsbOpenDeviceFunction() {}
+UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
+}
 
-UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {}
+UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
+}
 
 bool UsbOpenDeviceFunction::Prepare() {
   parameters_ = OpenDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbOpenDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDevice> device =
       GetDeviceOrOrCompleteWithError(parameters_->device);
-  if (!device) return;
+  if (!device)
+    return;
 
   handle_ = device->Open();
   if (!handle_) {
     SetError(kErrorOpen);
     AsyncWorkCompleted();
     return;
   }
 
   SetResult(PopulateConnectionHandle(
       manager_->Add(new UsbDeviceResource(extension_->id(), handle_)),
       handle_->device()->vendor_id(),
       handle_->device()->product_id()));
   AsyncWorkCompleted();
 }
 
-UsbListInterfacesFunction::UsbListInterfacesFunction() {}
+UsbListInterfacesFunction::UsbListInterfacesFunction() {
+}
 
-UsbListInterfacesFunction::~UsbListInterfacesFunction() {}
+UsbListInterfacesFunction::~UsbListInterfacesFunction() {
+}
 
 bool UsbListInterfacesFunction::Prepare() {
   parameters_ = ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbListInterfacesFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   scoped_refptr<UsbConfigDescriptor> config =
       device_handle->device()->ListInterfaces();
 
   if (!config) {
     SetError(kErrorCannotListInterfaces);
     AsyncWorkCompleted();
     return;
   }
 
   result_.reset(new base::ListValue());
 
   for (size_t i = 0, num_interfaces = config->GetNumInterfaces();
-      i < num_interfaces; ++i) {
-    scoped_refptr<const UsbInterfaceDescriptor>
-        usb_interface(config->GetInterface(i));
+       i < num_interfaces;
+       ++i) {
+    scoped_refptr<const UsbInterfaceDescriptor> usb_interface(
+        config->GetInterface(i));
     for (size_t j = 0, num_descriptors = usb_interface->GetNumAltSettings();
-            j < num_descriptors; ++j) {
-      scoped_refptr<const UsbInterfaceAltSettingDescriptor> descriptor
-          = usb_interface->GetAltSetting(j);
+         j < num_descriptors;
+         ++j) {
+      scoped_refptr<const UsbInterfaceAltSettingDescriptor> descriptor =
+          usb_interface->GetAltSetting(j);
       std::vector<linked_ptr<EndpointDescriptor> > endpoints;
       for (size_t k = 0, num_endpoints = descriptor->GetNumEndpoints();
-          k < num_endpoints; k++) {
-        scoped_refptr<const UsbEndpointDescriptor> endpoint
-            = descriptor->GetEndpoint(k);
+           k < num_endpoints;
+           k++) {
+        scoped_refptr<const UsbEndpointDescriptor> endpoint =
+            descriptor->GetEndpoint(k);
         linked_ptr<EndpointDescriptor> endpoint_desc(new EndpointDescriptor());
 
         TransferType type;
         Direction direction;
         SynchronizationType synchronization;
         UsageType usage;
 
         if (!ConvertTransferTypeSafely(endpoint->GetTransferType(), &type) ||
             !ConvertDirectionSafely(endpoint->GetDirection(), &direction) ||
             !ConvertSynchronizationTypeSafely(
@@ skipping 11 matching lines @@
         endpoint_desc->synchronization = synchronization;
         endpoint_desc->usage = usage;
 
         int* polling_interval = new int;
         endpoint_desc->polling_interval.reset(polling_interval);
         *polling_interval = endpoint->GetPollingInterval();
 
         endpoints.push_back(endpoint_desc);
       }
 
-      result_->Append(PopulateInterfaceDescriptor(
-          descriptor->GetInterfaceNumber(),
-          descriptor->GetAlternateSetting(),
-          descriptor->GetInterfaceClass(),
-          descriptor->GetInterfaceSubclass(),
-          descriptor->GetInterfaceProtocol(),
-          &endpoints));
+      result_->Append(
+          PopulateInterfaceDescriptor(descriptor->GetInterfaceNumber(),
+                                      descriptor->GetAlternateSetting(),
+                                      descriptor->GetInterfaceClass(),
+                                      descriptor->GetInterfaceSubclass(),
+                                      descriptor->GetInterfaceProtocol(),
+                                      &endpoints));
     }
   }
 
   SetResult(result_.release());
   AsyncWorkCompleted();
 }
 
 bool UsbListInterfacesFunction::ConvertDirectionSafely(
     const UsbEndpointDirection& input,
     usb::Direction* output) {
@@ skipping 23 matching lines @@
 
 bool UsbListInterfacesFunction::ConvertUsageTypeSafely(
     const UsbUsageType& input,
     usb::UsageType* output) {
   const bool converted = ConvertUsageTypeToApi(input, output);
   if (!converted)
     SetError(kErrorConvertUsageType);
   return converted;
 }
 
-UsbCloseDeviceFunction::UsbCloseDeviceFunction() {}
+UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
+}
 
-UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {}
+UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
+}
 
 bool UsbCloseDeviceFunction::Prepare() {
   parameters_ = CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbCloseDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   device_handle->Close();
   RemoveUsbDeviceResource(parameters_->handle.handle);
   AsyncWorkCompleted();
 }
 
-UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {}
+UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {
+}
 
-UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {}
+UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {
+}
 
 bool UsbClaimInterfaceFunction::Prepare() {
   parameters_ = ClaimInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbClaimInterfaceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   bool success = device_handle->ClaimInterface(parameters_->interface_number);
 
   if (!success)
     SetError(kErrorCannotClaimInterface);
   AsyncWorkCompleted();
 }
 
-UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {}
+UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {
+}
 
-UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {}
+UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {
+}
 
 bool UsbReleaseInterfaceFunction::Prepare() {
   parameters_ = ReleaseInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbReleaseInterfaceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   bool success = device_handle->ReleaseInterface(parameters_->interface_number);
   if (!success)
     SetError(kErrorCannotReleaseInterface);
   AsyncWorkCompleted();
 }
 
 UsbSetInterfaceAlternateSettingFunction::
-    UsbSetInterfaceAlternateSettingFunction() {}
+    UsbSetInterfaceAlternateSettingFunction() {
+}
 
 UsbSetInterfaceAlternateSettingFunction::
-    ~UsbSetInterfaceAlternateSettingFunction() {}
+    ~UsbSetInterfaceAlternateSettingFunction() {
+}
 
 bool UsbSetInterfaceAlternateSettingFunction::Prepare() {
   parameters_ = SetInterfaceAlternateSetting::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbSetInterfaceAlternateSettingFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   bool success = device_handle->SetInterfaceAlternateSetting(
-      parameters_->interface_number,
-      parameters_->alternate_setting);
+      parameters_->interface_number, parameters_->alternate_setting);
   if (!success)
     SetError(kErrorCannotSetInterfaceAlternateSetting);
 
   AsyncWorkCompleted();
 }
 
-UsbControlTransferFunction::UsbControlTransferFunction() {}
+UsbControlTransferFunction::UsbControlTransferFunction() {
+}
 
-UsbControlTransferFunction::~UsbControlTransferFunction() {}
+UsbControlTransferFunction::~UsbControlTransferFunction() {
+}
 
 bool UsbControlTransferFunction::Prepare() {
   parameters_ = ControlTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbControlTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   const ControlTransferInfo& transfer = parameters_->transfer_info;
 
   UsbEndpointDirection direction;
   UsbDeviceHandle::TransferRequestType request_type;
   UsbDeviceHandle::TransferRecipient recipient;
   size_t size = 0;
 
   if (!ConvertDirectionSafely(transfer.direction, &direction) ||
       !ConvertRequestTypeSafely(transfer.request_type, &request_type) ||
       !ConvertRecipientSafely(transfer.recipient, &recipient)) {
     AsyncWorkCompleted();
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
-  scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
-      transfer, direction, size);
+  scoped_refptr<net::IOBuffer> buffer =
+      CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
   device_handle->ControlTransfer(
       direction,
       request_type,
       recipient,
       transfer.request,
       transfer.value,
       transfer.index,
       buffer.get(),
       size,
       0,
       base::Bind(&UsbControlTransferFunction::OnCompleted, this));
 }
 
-UsbBulkTransferFunction::UsbBulkTransferFunction() {}
+UsbBulkTransferFunction::UsbBulkTransferFunction() {
+}
 
-UsbBulkTransferFunction::~UsbBulkTransferFunction() {}
+UsbBulkTransferFunction::~UsbBulkTransferFunction() {
+}
 
 bool UsbBulkTransferFunction::Prepare() {
   parameters_ = BulkTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbBulkTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   const GenericTransferInfo& transfer = parameters_->transfer_info;
 
   UsbEndpointDirection direction;
   size_t size = 0;
 
   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
     AsyncWorkCompleted();
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
-  scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
-      transfer, direction, size);
+  scoped_refptr<net::IOBuffer> buffer =
+      CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
   device_handle->BulkTransfer(
       direction,
       transfer.endpoint,
       buffer.get(),
       size,
       0,
       base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
 }
 
-UsbInterruptTransferFunction::UsbInterruptTransferFunction() {}
+UsbInterruptTransferFunction::UsbInterruptTransferFunction() {
+}
 
-UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {}
+UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {
+}
 
 bool UsbInterruptTransferFunction::Prepare() {
   parameters_ = InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbInterruptTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   const GenericTransferInfo& transfer = parameters_->transfer_info;
 
   UsbEndpointDirection direction;
   size_t size = 0;
 
   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
     AsyncWorkCompleted();
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
-  scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
-      transfer, direction, size);
+  scoped_refptr<net::IOBuffer> buffer =
+      CreateBufferForTransfer(transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
   device_handle->InterruptTransfer(
       direction,
       transfer.endpoint,
       buffer.get(),
       size,
       0,
       base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
 }
 
-UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {}
+UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {
+}
 
-UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {}
+UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {
+}
 
 bool UsbIsochronousTransferFunction::Prepare() {
   parameters_ = IsochronousTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbIsochronousTransferFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   const IsochronousTransferInfo& transfer = parameters_->transfer_info;
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
 
   size_t size = 0;
   UsbEndpointDirection direction;
 
   if (!ConvertDirectionSafely(generic_transfer.direction, &direction)) {
     AsyncWorkCompleted();
     return;
@@ skipping 12 matching lines @@
     CompleteWithError(kErrorInvalidPacketLength);
     return;
   }
   unsigned int packet_length = transfer.packet_length;
   const uint64 total_length = packets * packet_length;
   if (packets > size || total_length > size) {
     CompleteWithError(kErrorTransferLength);
     return;
   }
 
-  scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
-      generic_transfer, direction, size);
+  scoped_refptr<net::IOBuffer> buffer =
+      CreateBufferForTransfer(generic_transfer, direction, size);
   if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
   device_handle->IsochronousTransfer(
       direction,
       generic_transfer.endpoint,
       buffer.get(),
       size,
       packets,
       packet_length,
       0,
       base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
-UsbResetDeviceFunction::UsbResetDeviceFunction() {}
+UsbResetDeviceFunction::UsbResetDeviceFunction() {
+}
 
-UsbResetDeviceFunction::~UsbResetDeviceFunction() {}
+UsbResetDeviceFunction::~UsbResetDeviceFunction() {
+}
 
 bool UsbResetDeviceFunction::Prepare() {
   parameters_ = ResetDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbResetDeviceFunction::AsyncWorkStart() {
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandleOrCompleteWithError(parameters_->handle);
-  if (!device_handle) return;
+  if (!device_handle)
+    return;
 
   bool success = device_handle->ResetDevice();
   if (!success) {
     device_handle->Close();
     RemoveUsbDeviceResource(parameters_->handle.handle);
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions