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

net/socket/deterministic_socket_data_unittest.cc

Index: net/socket/deterministic_socket_data_unittest.cc
diff --git a/net/socket/deterministic_socket_data_unittest.cc b/net/socket/deterministic_socket_data_unittest.cc
index d0f568a5a52e6de92025812829603b1bfce9e910..b97cd408eb381bad349c9f428a1ecca5ca5e6b6d 100644
--- a/net/socket/deterministic_socket_data_unittest.cc
+++ b/net/socket/deterministic_socket_data_unittest.cc
@@ -130,7 +130,7 @@ void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data,
 void DeterministicSocketDataTest::AssertReadReturns(const char* data,
                                                     int len, int rv) {
   read_buf_ = new IOBuffer(len);
-  ASSERT_EQ(rv, sock_->Read(read_buf_, len, read_callback_.callback()));
+  ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
@@ -144,7 +144,7 @@ void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data,
   memcpy(buf->data(), data, len);
 
   // Issue the write, which will complete immediately
-  ASSERT_EQ(len, sock_->Write(buf, len, write_callback_.callback()));
+  ASSERT_EQ(len, sock_->Write(buf.get(), len, write_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data,
@@ -165,23 +165,32 @@ void DeterministicSocketDataTest::AssertWriteReturns(const char* data,
   memcpy(buf->data(), data, len);
 
   // Issue the read, which will complete asynchronously
-  ASSERT_EQ(rv, sock_->Write(buf, len, write_callback_.callback()));
+  ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback()));
 }
 
 void DeterministicSocketDataTest::ReentrantReadCallback(int len, int rv) {
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(len));
-  EXPECT_EQ(len, sock_->Read(read_buf,  len,
-      base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                 base::Unretained(this), len)));
+  EXPECT_EQ(len,
+            sock_->Read(
+                read_buf.get(),
+                len,
+                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
+                           base::Unretained(this),
+                           len)));
 }
 
 void DeterministicSocketDataTest::ReentrantWriteCallback(
     const char* data, int len, int rv) {
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(len));
   memcpy(write_buf->data(), data, len);
-  EXPECT_EQ(len, sock_->Write(write_buf,  len,
-      base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                 base::Unretained(this), data, len)));
+  EXPECT_EQ(len,
+            sock_->Write(
+                write_buf.get(),
+                len,
+                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
+                           base::Unretained(this),
+                           data,
+                           len)));
 }
 
 // ----------- Read
@@ -324,9 +333,13 @@ TEST_F(DeterministicSocketDataTest, SyncReadFromCompletionCallback) {
   data_->StopAfter(2);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf, kLen1,
-      base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
-                 base::Unretained(this), kLen2)));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(
+                read_buf.get(),
+                kLen1,
+                base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
+                           base::Unretained(this),
+                           kLen2)));
   data_->Run();
 }
 
@@ -465,9 +478,14 @@ TEST_F(DeterministicSocketDataTest, SyncWriteFromCompletionCallback) {
 
   scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
   memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, kLen1,
-      base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
-                 base::Unretained(this), kMsg2, kLen2)));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Write(
+                write_buf.get(),
+                kLen1,
+                base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
+                           base::Unretained(this),
+                           kMsg2,
+                           kLen2)));
   data_->Run();
 }