Fix missing callback chaining in UsbService.

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"
@@ skipping 284 matching lines @@
   device_for_test_ = device;
 }
 
 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());
+  result_.reset(new base::ListValue());
 
   if (device_for_test_) {
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(),
         device_for_test_);
 
     Device device;
-    result->Append(PopulateDevice(manager_->Add(resource), 0, 0));
-    SetResult(result.release());
+    result_->Append(PopulateDevice(manager_->Add(resource), 0, 0));
+    SetResult(result_.release());
     AsyncWorkCompleted();
     return;
   }
 
   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(vendor_id, product_id, &devices);
-  for (size_t i = 0; i < devices.size(); ++i) {
-    UsbDevice* const device = devices[i];
+  service->FindDevices(vendor_id, product_id, &devices_, base::Bind(
+      &UsbFindDevicesFunction::OnCompleted, this));
+}
+
+void UsbFindDevicesFunction::OnCompleted() {
+  for (size_t i = 0; i < devices_.size(); ++i) {
+    UsbDevice* const device = devices_[i];
     UsbDeviceResource* const resource = new UsbDeviceResource(
         extension_->id(), device);
 
     Device js_device;
-    result->Append(PopulateDevice(manager_->Add(resource),
-                                  vendor_id,
-                                  product_id));
+    result_->Append(PopulateDevice(manager_->Add(resource),
+                                   parameters_->options.vendor_id,
+                                   parameters_->options.product_id));
   }
 
-  SetResult(result.release());
+  SetResult(result_.release());
   AsyncWorkCompleted();
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {}
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {}
 
 bool UsbCloseDeviceFunction::Prepare() {
   parameters_ = CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
@@ skipping 279 matching lines @@
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
   device->device()->IsochronousTransfer(direction, generic_transfer.endpoint,
       buffer, size, transfer.packets, transfer.packet_length, 0, base::Bind(
           &UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
 }  // namespace extensions