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

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
@@ skipping 349 matching lines @@
   int rv;
   do {
     if (!socket_.get())
       break;
 
     DCHECK(!read_buffer_.get());
 
     // We release the read_buffer_ in the destructor if there is an error.
     read_buffer_ = new net::IOBuffer(kMaxMessage);
 
-    rv = socket_->Read(read_buffer_, kMaxMessage,
-                       base::Bind(&NetworkStats::OnReadComplete,
-                                  base::Unretained(this)));
+    rv = socket_->Read(
+        read_buffer_.get(),
+        kMaxMessage,
+        base::Bind(&NetworkStats::OnReadComplete, base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING)
       break;
 
     // If we have read all the data then return.
     if (ReadComplete(rv))
       break;
   } while (rv > 0);
 }
 
 int NetworkStats::SendData() {
   DCHECK(bytes_to_send_);   // We should have data to send.
   do {
     if (!write_buffer_.get()) {
       // Send a new packet.
       scoped_refptr<net::IOBufferWithSize> buffer(
           new net::IOBufferWithSize(bytes_to_send_));
-      GetEchoRequest(buffer);
-      write_buffer_ = new net::DrainableIOBuffer(buffer, bytes_to_send_);
+      GetEchoRequest(buffer.get());
+      write_buffer_ = new net::DrainableIOBuffer(buffer.get(), bytes_to_send_);
 
       // As soon as we write, a read could happen. Thus update all the book
       // keeping data.
       bytes_to_read_ += ReceivingPacketSize();
       ++packets_sent_;
       if (packets_sent_ >= packets_to_send_)
         sending_complete_ = true;
 
       uint32 packet_index = packet_number_ - base_packet_number_;
       DCHECK_GE(packet_index, 0u);
       DCHECK_LT(packet_index, packet_status_.size());
       packet_status_[packet_index].start_time_ = base::TimeTicks::Now();
     }
 
     if (!socket_.get())
       return net::ERR_UNEXPECTED;
-    int rv = socket_->Write(write_buffer_,
-                            write_buffer_->BytesRemaining(),
-                            base::Bind(&NetworkStats::OnWriteComplete,
-                                       base::Unretained(this)));
+    int rv = socket_->Write(
+        write_buffer_.get(),
+        write_buffer_->BytesRemaining(),
+        base::Bind(&NetworkStats::OnWriteComplete, base::Unretained(this)));
     if (rv < 0)
       return rv;
     DidSendData(rv);
   } while (bytes_to_send_);
   return net::OK;
 }
 
 uint32 NetworkStats::SendingPacketSize() const {
   return kVersionLength + kChecksumLength + kPayloadSizeLength + load_size_;
 }
@@ skipping 591 matching lines @@
         udp_stats_client->Start(
             host_resolver, server_address, histogram_port, has_proxy_server,
             kLargeTestBytesToSend, kMaximumSequentialPackets,
             net::CompletionCallback());
       }
       break;
   }
 }
 
 }  // namespace chrome_browser_net