Adding tests for USB extension API

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 <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/experimental_usb.h"
 
 namespace BulkTransfer = extensions::api::experimental_usb::BulkTransfer;
 namespace CloseDevice = extensions::api::experimental_usb::CloseDevice;
 namespace ControlTransfer = extensions::api::experimental_usb::ControlTransfer;
 namespace FindDevice = extensions::api::experimental_usb::FindDevice;
 namespace InterruptTransfer =
     extensions::api::experimental_usb::InterruptTransfer;
 namespace IsochronousTransfer =
     extensions::api::experimental_usb::IsochronousTransfer;
 using extensions::api::experimental_usb::Device;
 using std::vector;
 
+namespace {
+
+static UsbDevice* device_for_test_ = NULL;
+
+}  // namespace
+
 namespace extensions {
 
 UsbAsyncApiFunction::UsbAsyncApiFunction()
     : manager_(NULL) {
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 }
 
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ExtensionSystem::Get(profile())->usb_device_resource_manager();
   return manager_ != NULL;
 }
 
 UsbFindDeviceFunction::UsbFindDeviceFunction() : event_notifier_(NULL) {}
 
 UsbFindDeviceFunction::~UsbFindDeviceFunction() {}
 
+void UsbFindDeviceFunction::SetDeviceForTest(UsbDevice* device) {
+  device_for_test_ = device;
+}
+
 bool UsbFindDeviceFunction::Prepare() {
   parameters_ = FindDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   event_notifier_ = CreateEventNotifier(DeprecatedExtractSrcId(2));
   return true;
 }
 
 void UsbFindDeviceFunction::Work() {
-  UsbService* const service =
-      UsbServiceFactory::GetInstance()->GetForProfile(profile());
-  DCHECK(service) << "No UsbService associated with profile.";
+  UsbDevice* device = NULL;
+  if (device_for_test_) {
+    device = device_for_test_;
+  } else {
+    UsbService* const service = UsbServiceFactory::GetInstance()->GetForProfile(
+        profile());
+    device = service->FindDevice(parameters_->vendor_id,
+                                 parameters_->product_id);
+  }
 
-  UsbDevice* const device = service->FindDevice(parameters_->vendor_id,
-                                                parameters_->product_id);
   if (!device) {
     SetResult(base::Value::CreateNullValue());
     return;
   }
 
   UsbDeviceResource* const resource = new UsbDeviceResource(event_notifier_,
                                                             device);
 
   Device result;
   result.handle = manager_->Add(resource);
@@ skipping 10 matching lines @@
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {}
 
 bool UsbCloseDeviceFunction::Prepare() {
   parameters_ = CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
 }
 
 void UsbCloseDeviceFunction::Work() {
+  UsbDeviceResource* const device = manager_->Get(parameters_->device.handle);
+  if (device)
+    device->Close();
+
   manager_->Remove(parameters_->device.handle);
 }
 
 bool UsbCloseDeviceFunction::Respond() {
   return true;
 }
 
 UsbControlTransferFunction::UsbControlTransferFunction() {}
 
 UsbControlTransferFunction::~UsbControlTransferFunction() {}
@@ skipping 72 matching lines @@
   if (device) {
     device->IsochronousTransfer(parameters_->transfer_info);
   }
 }
 
 bool UsbIsochronousTransferFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions