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

chrome/test/chromedriver/net/adb_client_socket.cc

 // Copyright (c) 2013 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/test/chromedriver/net/adb_client_socket.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 123 matching lines @@
   void OnSocketAvailable(int result,
                          net::StreamSocket* socket) {
     if (!CheckNetResultOrDie(result))
       return;
 
     socket_.reset(socket);
 
     scoped_refptr<net::StringIOBuffer> request_buffer =
         new net::StringIOBuffer(request_);
 
-    result = socket_->Write(request_buffer, request_buffer->size(),
+    result = socket_->Write(
+        request_buffer.get(),
+        request_buffer->size(),
         base::Bind(&HttpOverAdbSocket::ReadResponse, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       ReadResponse(result);
   }
 
   void ReadResponse(int result) {
     if (!CheckNetResultOrDie(result))
       return;
 
     scoped_refptr<net::IOBuffer> response_buffer =
         new net::IOBuffer(kBufferSize);
 
-    result = socket_->Read(response_buffer, kBufferSize,
-        base::Bind(&HttpOverAdbSocket::OnResponseData, base::Unretained(this),
-                   response_buffer, -1));
+    result = socket_->Read(response_buffer.get(),
+                           kBufferSize,
+                           base::Bind(&HttpOverAdbSocket::OnResponseData,
+                                      base::Unretained(this),
+                                      response_buffer,
+                                      -1));
     if (result != net::ERR_IO_PENDING)
       OnResponseData(response_buffer, -1, result);
   }
 
   void OnResponseData(scoped_refptr<net::IOBuffer> response_buffer,
                       int bytes_total,
                       int result) {
     if (!CheckNetResultOrDie(result))
       return;
     if (result == 0) {
@@ skipping 27 matching lines @@
 
     if (bytes_total == static_cast<int>(response_.length())) {
       if (!command_callback_.is_null())
         command_callback_.Run(body_pos_, response_);
       else
         socket_callback_.Run(net::OK, socket_.release());
       delete this;
       return;
     }
 
-    result = socket_->Read(response_buffer, kBufferSize,
-        base::Bind(&HttpOverAdbSocket::OnResponseData, base::Unretained(this),
-                   response_buffer, bytes_total));
+    result = socket_->Read(response_buffer.get(),
+                           kBufferSize,
+                           base::Bind(&HttpOverAdbSocket::OnResponseData,
+                                      base::Unretained(this),
+                                      response_buffer,
+                                      bytes_total));
     if (result != net::ERR_IO_PENDING)
       OnResponseData(response_buffer, bytes_total, result);
   }
 
   bool CheckNetResultOrDie(int result) {
     if (result >= 0)
       return true;
     if (!command_callback_.is_null())
       command_callback_.Run(result, std::string());
     else
@@ skipping 149 matching lines @@
   int result = socket_->Connect(callback);
   if (result != net::ERR_IO_PENDING)
     callback.Run(result);
 }
 
 void AdbClientSocket::SendCommand(const std::string& command,
                                   bool is_void,
                                   const CommandCallback& callback) {
   scoped_refptr<net::StringIOBuffer> request_buffer =
       new net::StringIOBuffer(EncodeMessage(command));
-  int result = socket_->Write(request_buffer, request_buffer->size(),
-      base::Bind(&AdbClientSocket::ReadResponse, base::Unretained(this),
-                 callback, is_void));
+  int result = socket_->Write(request_buffer.get(),
+                              request_buffer->size(),
+                              base::Bind(&AdbClientSocket::ReadResponse,
+                                         base::Unretained(this),
+                                         callback,
+                                         is_void));
   if (result != net::ERR_IO_PENDING)
     ReadResponse(callback, is_void, result);
 }
 
 void AdbClientSocket::ReadResponse(const CommandCallback& callback,
                                    bool is_void,
                                    int result) {
   if (result < 0) {
     callback.Run(result, "IO error");
     return;
   }
   scoped_refptr<net::IOBuffer> response_buffer =
       new net::IOBuffer(kBufferSize);
-  result = socket_->Read(response_buffer, kBufferSize,
-      base::Bind(&AdbClientSocket::OnResponseHeader, base::Unretained(this),
-                 callback, is_void, response_buffer));
+  result = socket_->Read(response_buffer.get(),
+                         kBufferSize,
+                         base::Bind(&AdbClientSocket::OnResponseHeader,
+                                    base::Unretained(this),
+                                    callback,
+                                    is_void,
+                                    response_buffer));
   if (result != net::ERR_IO_PENDING)
     OnResponseHeader(callback, is_void, response_buffer, result);
 }
 
 void AdbClientSocket::OnResponseHeader(
     const CommandCallback& callback,
     bool is_void,
     scoped_refptr<net::IOBuffer> response_buffer,
     int result) {
   if (result <= 0) {
@@ skipping 45 matching lines @@
 
   bytes_left -= result;
   std::string new_response =
       response + std::string(response_buffer->data(), result);
   if (bytes_left == 0) {
     callback.Run(net::OK, new_response);
     return;
   }
 
   // Read tail
-  result = socket_->Read(response_buffer, kBufferSize,
-      base::Bind(&AdbClientSocket::OnResponseData, base::Unretained(this),
-                 callback, new_response, response_buffer, bytes_left));
+  result = socket_->Read(response_buffer.get(),
+                         kBufferSize,
+                         base::Bind(&AdbClientSocket::OnResponseData,
+                                    base::Unretained(this),
+                                    callback,
+                                    new_response,
+                                    response_buffer,
+                                    bytes_left));
   if (result > 0)
     OnResponseData(callback, new_response, response_buffer, bytes_left, result);
   else if (result != net::ERR_IO_PENDING)
     callback.Run(net::OK, new_response);
 }