Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 432 matching lines @@
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   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);
+    UsbDevice* const device = devices_[i].get();
+    UsbDeviceResource* const resource =
+        new UsbDeviceResource(extension_->id(), device);
 
     Device js_device;
     result_->Append(PopulateDevice(manager_->Add(resource),
                                    parameters_->options.vendor_id,
                                    parameters_->options.product_id));
   }
 
   SetResult(result_.release());
   AsyncWorkCompleted();
 }
@@ skipping 10 matching lines @@
 
 void UsbListInterfacesFunction::AsyncWorkStart() {
   UsbDeviceResource* const resource = GetUsbDeviceResource(
       parameters_->device.handle);
   if (!resource) {
     CompleteWithError(kErrorNoDevice);
     return;
   }
 
   config_ = new UsbConfigDescriptor();
-  resource->device()->ListInterfaces(config_, base::Bind(
-      &UsbListInterfacesFunction::OnCompleted, this));
+  resource->device()->ListInterfaces(
+      config_.get(), base::Bind(&UsbListInterfacesFunction::OnCompleted, this));
 }
 
 void UsbListInterfacesFunction::OnCompleted(bool success) {
   if (!success) {
     SetError(kErrorCannotListInterfaces);
     AsyncWorkCompleted();
     return;
   }
 
   result_.reset(new base::ListValue());
@@ skipping 238 matching lines @@
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
-  if (!buffer) {
+  if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->ControlTransfer(direction, request_type, recipient,
-      transfer.request, transfer.value, transfer.index, buffer, size, 0,
+  resource->device()->ControlTransfer(
+      direction,
+      request_type,
+      recipient,
+      transfer.request,
+      transfer.value,
+      transfer.index,
+      buffer.get(),
+      size,
+      0,
       base::Bind(&UsbControlTransferFunction::OnCompleted, this));
 }
 
 UsbBulkTransferFunction::UsbBulkTransferFunction() {}
 
 UsbBulkTransferFunction::~UsbBulkTransferFunction() {}
 
 bool UsbBulkTransferFunction::Prepare() {
   parameters_ = BulkTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
@@ skipping 18 matching lines @@
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
-  if (!buffer) {
+  if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->BulkTransfer(direction, transfer.endpoint,
-      buffer, size, 0, base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
+  resource->device()
+      ->BulkTransfer(direction,
+                     transfer.endpoint,
+                     buffer.get(),
+                     size,
+                     0,
+                     base::Bind(&UsbBulkTransferFunction::OnCompleted, this));
 }
 
 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {}
 
 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {}
 
 bool UsbInterruptTransferFunction::Prepare() {
   parameters_ = InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
@@ skipping 17 matching lines @@
     return;
   }
 
   if (!GetTransferSize(transfer, &size)) {
     CompleteWithError(kErrorInvalidTransferLength);
     return;
   }
 
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       transfer, direction, size);
-  if (!buffer) {
+  if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->InterruptTransfer(direction, transfer.endpoint, buffer,
-      size, 0, base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
+  resource->device()->InterruptTransfer(
+      direction,
+      transfer.endpoint,
+      buffer.get(),
+      size,
+      0,
+      base::Bind(&UsbInterruptTransferFunction::OnCompleted, this));
 }
 
 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {}
 
 UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {}
 
 bool UsbIsochronousTransferFunction::Prepare() {
   parameters_ = IsochronousTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
@@ skipping 33 matching lines @@
   }
   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);
-  if (!buffer) {
+  if (!buffer.get()) {
     CompleteWithError(kErrorMalformedParameters);
     return;
   }
 
-  resource->device()->IsochronousTransfer(direction, generic_transfer.endpoint,
-      buffer, size, packets, packet_length, 0, base::Bind(
-          &UsbIsochronousTransferFunction::OnCompleted, this));
+  resource->device()->IsochronousTransfer(
+      direction,
+      generic_transfer.endpoint,
+      buffer.get(),
+      size,
+      packets,
+      packet_length,
+      0,
+      base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
 }
 
 UsbResetDeviceFunction::UsbResetDeviceFunction() {}
 
 UsbResetDeviceFunction::~UsbResetDeviceFunction() {}
 
 bool UsbResetDeviceFunction::Prepare() {
   parameters_ = ResetDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters_.get());
   return true;
@@ skipping 46 matching lines @@
 }
 
 void UsbResetDeviceFunction::OnError() {
   RemoveUsbDeviceResource(parameters_->device.handle);
   SetError(kErrorResetDevice);
   SetResult(Value::CreateBooleanValue(false));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions