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"
@@ skipping 21 matching lines @@
 }
 
 UsbAsyncApiFunction::~UsbAsyncApiFunction() {
 }
 
 bool UsbAsyncApiFunction::PrePrepare() {
   manager_ = ExtensionSystem::Get(profile())->usb_device_resource_manager();
   return manager_ != NULL;
 }
 
+UsbDevice* UsbFindDeviceFunction::device_for_test_ = 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());
+    DCHECK(service) << "No UsbService associated with profile.";

[asargent_no_longer_on_chrome, 2012/08/14 22:31:06]

nit: Since we'll crash on the next line anyway if |service| is NULL, consider
just making this a CHECK instead of DCHECK.

Alternatively, if there are legitimate scenarios where |service| could come back
NULL, then just leave |device| NULL and fall through to the CreateNullValue case
below.

 
-  UsbDevice* const device = service->FindDevice(parameters_->vendor_id,
-                                                parameters_->product_id);
+    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