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

chrome/browser/devtools/tethering_adb_filter.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/browser/devtools/tethering_adb_filter.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 82 matching lines @@
       SelfDestruct();
       return;
     }
 
     Pump(host_socket_.get(), remote_socket_.get());
     Pump(remote_socket_.get(), host_socket_.get());
   }
 
   void Pump(net::StreamSocket* from, net::StreamSocket* to) {
     scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
-    int result = from->Read(buffer, kBufferSize,
-          base::Bind(&SocketTunnel::OnRead, base::Unretained(this), from, to,
-                     buffer));
+    int result = from->Read(
+        buffer.get(),
+        kBufferSize,
+        base::Bind(
+            &SocketTunnel::OnRead, base::Unretained(this), from, to, buffer));
     if (result != net::ERR_IO_PENDING)
       OnRead(from, to, buffer, result);
   }
 
   void OnRead(net::StreamSocket* from,
               net::StreamSocket* to,
               scoped_refptr<net::IOBuffer> buffer,
               int result) {
     if (result <= 0) {
       SelfDestruct();
       return;
     }
 
     int total = result;
     scoped_refptr<net::DrainableIOBuffer> drainable =
-        new net::DrainableIOBuffer(buffer, total);
+        new net::DrainableIOBuffer(buffer.get(), total);
 
     ++pending_writes_;
-    result = to->Write(drainable, total,
+    result = to->Write(drainable.get(),
+                       total,
                        base::Bind(&SocketTunnel::OnWritten,
-                                  base::Unretained(this), drainable, from, to));
+                                  base::Unretained(this),
+                                  drainable,
+                                  from,
+                                  to));
     if (result != net::ERR_IO_PENDING)
       OnWritten(drainable, from, to, result);
   }
 
   void OnWritten(scoped_refptr<net::DrainableIOBuffer> drainable,
                  net::StreamSocket* from,
                  net::StreamSocket* to,
                  int result) {
     --pending_writes_;
     if (result < 0) {
       SelfDestruct();
       return;
     }
 
     drainable->DidConsume(result);
     if (drainable->BytesRemaining() > 0) {
       ++pending_writes_;
-      result = to->Write(drainable, drainable->BytesRemaining(),
+      result = to->Write(drainable.get(),
+                         drainable->BytesRemaining(),
                          base::Bind(&SocketTunnel::OnWritten,
-                                    base::Unretained(this), drainable, from,
+                                    base::Unretained(this),
+                                    drainable,
+                                    from,
                                     to));
       if (result != net::ERR_IO_PENDING)
         OnWritten(drainable, from, to, result);
       return;
     }
 
     if (pending_destruction_) {
       SelfDestruct();
       return;
     }
@@ skipping 97 matching lines @@
 
   std::string location;
   if (!params->GetString(kLocationAttribute, &location))
     return;
 
   if (method == kTetheringBind)
     requested_ports_[port] = location;
   else
     requested_ports_.erase(port);
 }