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

content/browser/devtools/tethering_handler.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 "content/browser/devtools/tethering_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 34 matching lines @@
              net::StreamSocket* client_socket)
       : client_socket_(client_socket),
         delegate_(delegate),
         wire_buffer_size_(0),
         pending_destruction_(false) {
   }
 
   std::string Init() {
     std::string channel_name;
     server_socket_ = delegate_->CreateSocketForTethering(this, &channel_name);
-    if (!server_socket_ || channel_name.empty())
+    if (!server_socket_.get() || channel_name.empty())
       SelfDestruct();
     return channel_name;
   }
 
   virtual ~SocketPump() { }
 
  private:
   virtual void DidAccept(net::StreamListenSocket* server,
                          net::StreamListenSocket* socket) OVERRIDE {
-    if (accepted_socket_)
+    if (accepted_socket_.get())
       return;
 
     buffer_ = new net::IOBuffer(kBufferSize);
     wire_buffer_ = new net::GrowableIOBuffer();
     wire_buffer_->SetCapacity(kBufferSize);
 
     accepted_socket_ = socket;
-    int result = client_socket_->Read(buffer_, kBufferSize,
-                                      base::Bind(&SocketPump::OnClientRead,
-                                                 base::Unretained(this)));
+    int result = client_socket_->Read(
+        buffer_.get(),
+        kBufferSize,
+        base::Bind(&SocketPump::OnClientRead, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnClientRead(result);
   }
 
   virtual void DidRead(net::StreamListenSocket* socket,
                        const char* data,
                        int len) OVERRIDE {
     int old_size = wire_buffer_size_;
     wire_buffer_size_ += len;
     while (wire_buffer_->capacity() < wire_buffer_size_)
       wire_buffer_->SetCapacity(wire_buffer_->capacity() * 2);
     memcpy(wire_buffer_->StartOfBuffer() + old_size, data, len);
     if (old_size != wire_buffer_->offset())
       return;
     OnClientWrite(0);
   }
 
   virtual void DidClose(net::StreamListenSocket* socket) OVERRIDE {
     SelfDestruct();
   }
 
   void OnClientRead(int result) {
     if (result <= 0) {
       SelfDestruct();
       return;
     }
 
     accepted_socket_->Send(buffer_->data(), result);
-    result = client_socket_->Read(buffer_, kBufferSize,
-                                  base::Bind(&SocketPump::OnClientRead,
-                                             base::Unretained(this)));
+    result = client_socket_->Read(
+        buffer_.get(),
+        kBufferSize,
+        base::Bind(&SocketPump::OnClientRead, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnClientRead(result);
   }
 
   void OnClientWrite(int result) {
     if (result < 0)
       SelfDestruct();
 
     wire_buffer_->set_offset(wire_buffer_->offset() + result);
 
     int remaining = wire_buffer_size_ - wire_buffer_->offset();
     if (remaining == 0) {
       if (pending_destruction_)
         SelfDestruct();
       return;
     }
 
 
     if (remaining > kBufferSize)
       remaining = kBufferSize;
 
     scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(remaining);
     memcpy(buffer->data(), wire_buffer_->data(), remaining);
     result = client_socket_->Write(
-        buffer, remaining, base::Bind(&SocketPump::OnClientWrite,
-                                      base::Unretained(this)));
+        buffer.get(),
+        remaining,
+        base::Bind(&SocketPump::OnClientWrite, base::Unretained(this)));
 
     // Shrink buffer
     int offset = wire_buffer_->offset();
     if (offset > kBufferSize) {
       memcpy(wire_buffer_->StartOfBuffer(), wire_buffer_->data(),
           wire_buffer_size_ - offset);
       wire_buffer_size_ -= offset;
       wire_buffer_->set_offset(0);
     }
 
@@ skipping 154 matching lines @@
   BoundSockets::iterator it = bound_sockets_.find(port);
   if (it == bound_sockets_.end())
     return command->InternalErrorResponse("Port is not bound");
 
   delete it->second;
   bound_sockets_.erase(it);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content