Remove implicit conversions from scoped_refptr to T* in chrome/browser/devtools/

chrome/browser/devtools/device/usb/android_usb_device.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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
@@ skipping 162 matching lines @@
 AdbMessage::~AdbMessage() {
 }
 
 static void RespondOnCallerThread(const AndroidUsbDevicesCallback& callback,
                                   AndroidUsbDevices* new_devices) {
   scoped_ptr<AndroidUsbDevices> devices(new_devices);
 
   // Add raw pointers to the newly claimed devices.
   for (AndroidUsbDevices::iterator it = devices->begin(); it != devices->end();
        ++it) {
-    g_devices.Get().push_back(*it);
+    g_devices.Get().push_back(it->get());
   }
 
   // Return all claimed devices.
   AndroidUsbDevices result(g_devices.Get().begin(), g_devices.Get().end());
   callback.Run(result);
 }
 
 static void RespondOnFileThread(
     const AndroidUsbDevicesCallback& callback,
     AndroidUsbDevices* devices,
     scoped_refptr<base::MessageLoopProxy> caller_message_loop_proxy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   caller_message_loop_proxy->PostTask(
       FROM_HERE,
       base::Bind(&RespondOnCallerThread, callback, devices));
 }
 
 static void OpenAndroidDeviceOnFileThread(
     AndroidUsbDevices* devices,
     crypto::RSAPrivateKey* rsa_key,
     const base::Closure& barrier,
     scoped_refptr<UsbDevice> device,
     int interface_id,
     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (success) {
     scoped_refptr<UsbConfigDescriptor> config = device->ListInterfaces();
     scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
-    if (usb_handle) {
+    if (usb_handle.get()) {
       scoped_refptr<AndroidUsbDevice> android_device =
         ClaimInterface(rsa_key, usb_handle, config->GetInterface(interface_id),
                        interface_id);
       if (android_device.get())
         devices->push_back(android_device.get());
       else
         usb_handle->Close();
     }
   }
   barrier.Run();
 }
 
 static int CountOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   UsbService* service = UsbService::GetInstance();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
   int device_count = 0;
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
     scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config)
+    if (!config.get())
       continue;
 
     for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
       if (IsAndroidInterface(config->GetInterface(j)))
         ++device_count;
     }
   }
   return device_count;
 }
 
@@ skipping 12 matching lines @@
   AndroidUsbDevices* devices = new AndroidUsbDevices();
   base::Closure barrier = base::BarrierClosure(
       usb_devices.size(), base::Bind(&RespondOnFileThread,
                                      callback,
                                      devices,
                                      caller_message_loop_proxy));
 
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
     scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config) {
+    if (!config.get()) {
       barrier.Run();
       continue;
     }
 
     bool has_android_interface = false;
     for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
       if (!IsAndroidInterface(config->GetInterface(j)))
         continue;
 
       // Request permission on Chrome OS.
@@ skipping 22 matching lines @@
       callback);
 }
 
 // static
 void AndroidUsbDevice::Enumerate(crypto::RSAPrivateKey* rsa_key,
                                  const AndroidUsbDevicesCallback& callback) {
 
   // Collect devices with closed handles.
   for (std::vector<AndroidUsbDevice*>::iterator it = g_devices.Get().begin();
        it != g_devices.Get().end(); ++it) {
-    if ((*it)->usb_handle_) {
+    if ((*it)->usb_handle_.get()) {
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
           base::Bind(&AndroidUsbDevice::TerminateIfReleased, *it,
                      (*it)->usb_handle_));
     }
   }
 
   // Then look for the new devices.
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&EnumerateOnFileThread, rsa_key, callback,
                                      base::MessageLoopProxy::current()));
@@ skipping 23 matching lines @@
 void AndroidUsbDevice::InitOnCallerThread() {
   if (message_loop_)
     return;
   message_loop_ = base::MessageLoop::current();
   Queue(new AdbMessage(AdbMessage::kCommandCNXN, kVersion, kMaxPayload,
                        kHostConnectMessage));
   ReadHeader();
 }
 
 net::StreamSocket* AndroidUsbDevice::CreateSocket(const std::string& command) {
-  if (!usb_handle_)
+  if (!usb_handle_.get())
     return NULL;
 
   uint32 socket_id = ++last_socket_id_;
   sockets_[socket_id] = new AndroidUsbSocket(this, socket_id, command,
       base::Bind(&AndroidUsbDevice::SocketDeleted, this));
   return sockets_[socket_id];
 }
 
 void AndroidUsbDevice::Send(uint32 command,
                             uint32 arg0,
@@ skipping 51 matching lines @@
       // Send a zero length packet.
       outgoing_queue_.push(new net::IOBufferWithSize(0));
     }
   }
   ProcessOutgoing();
 }
 
 void AndroidUsbDevice::ProcessOutgoing() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (outgoing_queue_.empty() || !usb_handle_)
+  if (outgoing_queue_.empty() || !usb_handle_.get())
     return;
 
   BulkMessage message = outgoing_queue_.front();
   outgoing_queue_.pop();
   DumpMessage(true, message->data(), message->size());
-  usb_handle_->BulkTransfer(
-      usb_service::USB_DIRECTION_OUTBOUND, outbound_address_,
-      message, message->size(), kUsbTimeout,
-      base::Bind(&AndroidUsbDevice::OutgoingMessageSent,
-                 weak_factory_.GetWeakPtr()));
+  usb_handle_->BulkTransfer(usb_service::USB_DIRECTION_OUTBOUND,
+                            outbound_address_,
+                            message.get(),
+                            message->size(),
+                            kUsbTimeout,
+                            base::Bind(&AndroidUsbDevice::OutgoingMessageSent,
+                                       weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::OutgoingMessageSent(UsbTransferStatus status,
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (status != usb_service::USB_TRANSFER_COMPLETED)
     return;
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::ProcessOutgoing, this));
 }
 
 void AndroidUsbDevice::ReadHeader() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (!usb_handle_)
+  if (!usb_handle_.get())
     return;
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kHeaderSize);
   usb_handle_->BulkTransfer(
-      usb_service::USB_DIRECTION_INBOUND, inbound_address_,
-      buffer, kHeaderSize, kUsbTimeout,
-      base::Bind(&AndroidUsbDevice::ParseHeader,
-                 weak_factory_.GetWeakPtr()));
+      usb_service::USB_DIRECTION_INBOUND,
+      inbound_address_,
+      buffer.get(),
+      kHeaderSize,
+      kUsbTimeout,
+      base::Bind(&AndroidUsbDevice::ParseHeader, weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::ParseHeader(UsbTransferStatus status,
                                    scoped_refptr<net::IOBuffer> buffer,
                                    size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (status == usb_service::USB_TRANSFER_TIMEOUT) {
     message_loop_->PostTask(FROM_HERE,
                             base::Bind(&AndroidUsbDevice::ReadHeader, this));
@@ skipping 28 matching lines @@
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::ReadBody, this,
                                      message, data_length, data_check));
 }
 
 void AndroidUsbDevice::ReadBody(scoped_refptr<AdbMessage> message,
                                 uint32 data_length,
                                 uint32 data_check) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (!usb_handle_)
+  if (!usb_handle_.get())
     return;
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(data_length);
-  usb_handle_->BulkTransfer(
-      usb_service::USB_DIRECTION_INBOUND, inbound_address_,
-      buffer, data_length, kUsbTimeout,
-      base::Bind(&AndroidUsbDevice::ParseBody, weak_factory_.GetWeakPtr(),
-                 message, data_length, data_check));
+  usb_handle_->BulkTransfer(usb_service::USB_DIRECTION_INBOUND,
+                            inbound_address_,
+                            buffer.get(),
+                            data_length,
+                            kUsbTimeout,
+                            base::Bind(&AndroidUsbDevice::ParseBody,
+                                       weak_factory_.GetWeakPtr(),
+                                       message,
+                                       data_length,
+                                       data_check));
 }
 
 void AndroidUsbDevice::ParseBody(scoped_refptr<AdbMessage> message,
                                  uint32 data_length,
                                  uint32 data_check,
                                  UsbTransferStatus status,
                                  scoped_refptr<net::IOBuffer> buffer,
                                  size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
@@ skipping 91 matching lines @@
 }
 
 void AndroidUsbDevice::Terminate() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   std::vector<AndroidUsbDevice*>::iterator it =
       std::find(g_devices.Get().begin(), g_devices.Get().end(), this);
   if (it != g_devices.Get().end())
     g_devices.Get().erase(it);
 
-  if (!usb_handle_)
+  if (!usb_handle_.get())
     return;
 
   // Make sure we zero-out handle so that closing connections did not open
   // new connections.
   scoped_refptr<UsbDeviceHandle> usb_handle = usb_handle_;
   usb_handle_ = NULL;
 
   // Iterate over copy.
   AndroidUsbSockets sockets(sockets_);
   for (AndroidUsbSockets::iterator it = sockets.begin();
        it != sockets.end(); ++it) {
     it->second->Terminated(true);
   }
   DCHECK(sockets_.empty());
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }