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

net/base/upload_data_stream_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/base/upload_data_stream.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 25 matching lines @@
 const char kTestData[] = "0123456789";
 const size_t kTestDataSize = arraysize(kTestData) - 1;
 const size_t kTestBufferSize = 1 << 14;  // 16KB.
 
 // Reads data from the upload data stream, and returns the data as string.
 std::string ReadFromUploadDataStream(UploadDataStream* stream) {
   std::string data_read;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback callback;
-    const int result = stream->Read(buf, kTestBufferSize, callback.callback());
+    const int result =
+        stream->Read(buf.get(), kTestBufferSize, callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : callback.WaitForResult();
     data_read.append(buf->data(), bytes_read);
   }
   return data_read;
 }
 
 // A mock class of UploadElementReader.
 class MockUploadElementReader : public UploadElementReader {
  public:
@@ skipping 90 matching lines @@
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
-    int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback());
+    int bytes_read =
+        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, File) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                   &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   element_readers_.push_back(new UploadFileElementReader(
       base::MessageLoopProxy::current(),
       temp_file_path, 0, kuint64max, base::Time()));
 
   TestCompletionCallback init_callback;
   UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
-    ASSERT_EQ(ERR_IO_PENDING,
-              stream.Read(buf, kTestBufferSize, read_callback.callback()));
+    ASSERT_EQ(
+        ERR_IO_PENDING,
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
   }
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                   &temp_file_path));
@@ skipping 13 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kFakeSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   uint64 read_counter = 0;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
-    ASSERT_EQ(ERR_IO_PENDING,
-              stream.Read(buf, kTestBufferSize, read_callback.callback()));
+    ASSERT_EQ(
+        ERR_IO_PENDING,
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
     int bytes_read = read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
     read_counter += bytes_read;
     EXPECT_EQ(read_counter, stream.position());
   }
   // UpdateDataStream will pad out the file with 0 bytes so that the HTTP
   // transaction doesn't hang.  Therefore we expected the full size.
   EXPECT_EQ(kFakeSize, read_counter);
   EXPECT_EQ(read_counter, stream.position());
 }
@@ skipping 16 matching lines @@
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_EQ(kTestDataSize*2, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
-            stream.Read(buf, kTestBufferSize, CompletionCallback()));
-  EXPECT_EQ(kTestDataSize*2, stream.position());
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
+            stream.Read(buf.get(), kTestBufferSize, CompletionCallback()));
+  EXPECT_EQ(kTestDataSize * 2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
   // The buffer is filled with zero.
   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(UploadDataStreamTest, ReadErrorAsync) {
   // This element cannot be read.
   MockUploadElementReader* reader =
@@ skipping 16 matching lines @@
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
   TestCompletionCallback read_callback;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestBufferSize, read_callback.callback()));
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback.WaitForResult());
+            stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
   EXPECT_EQ(kTestDataSize*2, stream.position());
   EXPECT_TRUE(stream.IsEOF());
 
   // The buffer is filled with zero.
   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(UploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
@@ skipping 17 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kStreamSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
     TestCompletionCallback read_callback;
     const int result =
-        stream.Read(buf, kTestBufferSize, read_callback.callback());
+        stream.Read(buf.get(), kTestBufferSize, read_callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kStreamSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 TEST_F(UploadDataStreamTest, Chunk) {
   const uint64 kStreamSize = kTestDataSize*2;
   UploadDataStream stream(UploadDataStream::CHUNKED, 0);
   stream.AppendChunk(kTestData, kTestDataSize, false);
   stream.AppendChunk(kTestData, kTestDataSize, true);
 
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(0U, stream.size());  // Content-Length is 0 for chunked data.
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream.IsEOF()) {
-    int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback());
+    int bytes_read =
+        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
   EXPECT_EQ(kStreamSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 // Init() with on-memory and not-on-memory readers.
 TEST_F(UploadDataStreamTest, InitAsync) {
   // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
@@ skipping 69 matching lines @@
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
   UploadDataStream stream(&element_readers_, 0);
 
   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
-  int bytes_read = stream.Read(buf, kTestDataSize, CompletionCallback());
+  int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback());
   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
   EXPECT_EQ(kTestDataSize, stream.position());
   ASSERT_TRUE(stream.IsEOF());
 }
 
 // Async Read() with on-memory and not-on-memory readers.
 TEST_F(UploadDataStreamTest, ReadAsync) {
   // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
@@ skipping 22 matching lines @@
   // Run Init().
   TestCompletionCallback init_callback;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 
   // Consume the first element.
   TestCompletionCallback read_callback1;
   EXPECT_EQ(static_cast<int>(kTestDataSize),
-            stream.Read(buf, kTestDataSize, read_callback1.callback()));
+            stream.Read(buf.get(), kTestDataSize, read_callback1.callback()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(read_callback1.have_result());
 
   // Consume the second element.
   TestCompletionCallback read_callback2;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestDataSize, read_callback2.callback()));
+            stream.Read(buf.get(), kTestDataSize, read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult());
 
   // Consume the third and the fourth elements.
   TestCompletionCallback read_callback3;
-  ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf, kTestDataSize*2, read_callback3.callback()));
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback3.WaitForResult());
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(buf.get(), kTestDataSize * 2, read_callback3.callback()));
+  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
+            read_callback3.WaitForResult());
 }
 
 void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path,
                                              const base::Time& time,
                                              bool error_expected) {
   // Don't use element_readers_ here, as this function is called twice, and
   // reusing element_readers_ is wrong.
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadFileElementReader(
       base::MessageLoopProxy::current(), file_path, 1, 2, time));
@@ skipping 131 matching lines @@
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
 
   // Read some.
   TestCompletionCallback read_callback1;
   std::vector<char> buf(kTestDataSize + kTestDataSize/2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(),
-                                        read_callback1.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
   EXPECT_EQ(buf.size(), stream.position());
 
   // Call Init to reset the state.
   TestCompletionCallback init_callback2;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
 }
 
 TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                   &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
@@ skipping 18 matching lines @@
   TestCompletionCallback init_callback2;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(init_callback1.have_result());
 }
 
 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   base::FilePath temp_file_path;
@@ skipping 18 matching lines @@
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
 
   // Start reading.
   TestCompletionCallback read_callback1;
   std::vector<char> buf(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(),
-                                        read_callback1.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   TestCompletionCallback init_callback2;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
-  EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(),
-                                        read_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream.Read(
+                wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream.IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
 }
 
 }  // namespace net