Remove implicit conversions from scoped_refptr to T* in extensions/

extensions/browser/api/usb/usb_api.cc

 // Copyright 2014 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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 420 matching lines @@
 
   UsbService* service = UsbService::GetInstance();
   if (!service) {
     CompleteWithError(kErrorInitService);
     return NULL;
   }
   scoped_refptr<UsbDevice> device;
 
   device = service->GetDeviceById(input_device.device);
 
-  if (!device) {
+  if (!device.get()) {
     CompleteWithError(kErrorNoDevice);
     return NULL;
   }
 
   if (device->vendor_id() != input_device.vendor_id ||
       device->product_id() != input_device.product_id) {
     // Must act as if there is no such a device.
     // Otherwise can be used to finger print unauthorized devices.
     CompleteWithError(kErrorNoDevice);
     return NULL;
@@ skipping 133 matching lines @@
 #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();
-    if (device_handle)
+    if (device_handle.get())
       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,
@@ skipping 96 matching lines @@
 
 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)
+  if (!device.get())
     return;
 
   handle_ = device->Open();
-  if (!handle_) {
+  if (!handle_.get()) {
     SetError(kErrorOpen);
     AsyncWorkCompleted();
     return;
   }
 
   SetResult(PopulateConnectionHandle(
       manager_->Add(new UsbDeviceResource(extension_->id(), handle_)),
       handle_->GetDevice()->vendor_id(),
       handle_->GetDevice()->product_id()));
   AsyncWorkCompleted();
 }
 
 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)
+  if (!device_handle.get())
     return;
 
   scoped_refptr<UsbConfigDescriptor> config =
       device_handle->GetDevice()->ListInterfaces();
 
-  if (!config) {
+  if (!config.get()) {
     SetError(kErrorCannotListInterfaces);
     AsyncWorkCompleted();
     return;
   }
 
   result_.reset(new base::ListValue());
 
   for (size_t i = 0, num_interfaces = config->GetNumInterfaces();
        i < num_interfaces;
        ++i) {
@@ skipping 99 matching lines @@
 
 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)
+  if (!device_handle.get())
     return;
 
   device_handle->Close();
   RemoveUsbDeviceResource(parameters_->handle.handle);
   AsyncWorkCompleted();
 }
 
 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)
+  if (!device_handle.get())
     return;
 
   bool success = device_handle->ClaimInterface(parameters_->interface_number);
 
   if (!success)
     SetError(kErrorCannotClaimInterface);
   AsyncWorkCompleted();
 }
 
 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)
+  if (!device_handle.get())
     return;
 
   bool success = device_handle->ReleaseInterface(parameters_->interface_number);
   if (!success)
     SetError(kErrorCannotReleaseInterface);
   AsyncWorkCompleted();
 }
 
 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)
+  if (!device_handle.get())
     return;
 
   bool success = device_handle->SetInterfaceAlternateSetting(
       parameters_->interface_number, parameters_->alternate_setting);
   if (!success)
     SetError(kErrorCannotSetInterfaceAlternateSetting);
 
   AsyncWorkCompleted();
 }
 
 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)
+  if (!device_handle.get())
     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) ||
@@ skipping 36 matching lines @@
 
 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)
+  if (!device_handle.get())
     return;
 
   const GenericTransferInfo& transfer = parameters_->transfer_info;
 
   UsbEndpointDirection direction;
   size_t size = 0;
 
   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
     AsyncWorkCompleted();
     return;
@@ skipping 28 matching lines @@
 
 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)
+  if (!device_handle.get())
     return;
 
   const GenericTransferInfo& transfer = parameters_->transfer_info;
 
   UsbEndpointDirection direction;
   size_t size = 0;
 
   if (!ConvertDirectionSafely(transfer.direction, &direction)) {
     AsyncWorkCompleted();
     return;
@@ skipping 28 matching lines @@
 
 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)
+  if (!device_handle.get())
     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();
@@ skipping 46 matching lines @@
 
 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)
+  if (!device_handle.get())
     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