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

net/udp/udp_socket_unittest.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 "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 15 matching lines @@
 class UDPSocketTest : public PlatformTest {
  public:
   UDPSocketTest()
       : buffer_(new IOBufferWithSize(kMaxRead)) {
   }
 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
     TestCompletionCallback callback;
 
-    int rv = socket->RecvFrom(buffer_, kMaxRead, &recv_from_address_,
-                              callback.callback());
+    int rv = socket->RecvFrom(
+        buffer_.get(), kMaxRead, &recv_from_address_, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return std::string();  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
   // If |address| is specified, then it is used for the destination
   // to send to. Otherwise, will send to the last socket this server
   // received from.
   int SendToSocket(UDPServerSocket* socket, std::string msg) {
     return SendToSocket(socket, msg, recv_from_address_);
   }
 
   int SendToSocket(UDPServerSocket* socket,
                    std::string msg,
                    const IPEndPoint& address) {
     TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
-        new DrainableIOBuffer(io_buffer, length));
+        new DrainableIOBuffer(io_buffer.get(), length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
-      int rv = socket->SendTo(buffer, buffer->BytesRemaining(),
-                              address, callback.callback());
+      int rv = socket->SendTo(
+          buffer.get(), buffer->BytesRemaining(), address, callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
   std::string ReadSocket(UDPClientSocket* socket) {
     TestCompletionCallback callback;
 
-    int rv = socket->Read(buffer_, kMaxRead, callback.callback());
+    int rv = socket->Read(buffer_.get(), kMaxRead, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return std::string();  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
   int WriteSocket(UDPClientSocket* socket, std::string msg) {
     TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
-        new DrainableIOBuffer(io_buffer, length));
+        new DrainableIOBuffer(io_buffer.get(), length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
-      int rv = socket->Write(buffer, buffer->BytesRemaining(),
-                             callback.callback());
+      int rv = socket->Write(
+          buffer.get(), buffer->BytesRemaining(), callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
@@ skipping 398 matching lines @@
 // Close the socket while read is pending.
 TEST_F(UDPSocketTest, CloseWithPendingRead) {
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", 0, &bind_address);
   UDPServerSocket server(NULL, NetLog::Source());
   int rv = server.Listen(bind_address);
   EXPECT_EQ(OK, rv);
 
   TestCompletionCallback callback;
   IPEndPoint from;
-  rv = server.RecvFrom(buffer_, kMaxRead, &from, callback.callback());
+  rv = server.RecvFrom(buffer_.get(), kMaxRead, &from, callback.callback());
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
 
   EXPECT_FALSE(callback.have_result());
 }
 
 #if defined(OS_ANDROID)
 // Some Android devices do not support multicast socket.
 // The ones supporting multicast need WifiManager.MulitcastLock to enable it.
@@ skipping 44 matching lines @@
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(-1));
 
   EXPECT_EQ(OK, socket.Bind(bind_address));
 
   socket.Close();
 }
 
 }  // namespace
 
 }  // namespace net