Call scoped_refptr<T>::get() rather than relying on 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 152 matching lines @@
   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()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  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);
@@ skipping 12 matching lines @@
   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));
   const uint64 kFakeSize = kTestDataSize*2;
 
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  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(kFakeSize, stream.size());
   EXPECT_EQ(0U, stream.position());
   EXPECT_FALSE(stream.IsEOF());
   uint64 read_counter = 0;
@@ skipping 90 matching lines @@
 
 TEST_F(UploadDataStreamTest, FileAndBytes) {
   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));
 
   const uint64 kFileRangeOffset = 1;
   const uint64 kFileRangeLength = 4;
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, kFileRangeOffset, kFileRangeLength, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  kFileRangeOffset,
+                                  kFileRangeLength,
+                                  base::Time()));
 
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
 
   const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
   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());
@@ skipping 179 matching lines @@
             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));
+      base::MessageLoopProxy::current().get(), file_path, 1, 2, time));
 
   TestCompletionCallback init_callback;
   UploadDataStream stream(&element_readers, 0);
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
   int error_code = init_callback.WaitForResult();
   if (error_expected)
     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
   else
     ASSERT_EQ(OK, error_code);
 }
@@ skipping 20 matching lines @@
 TEST_F(UploadDataStreamTest, MultipleInit) {
   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));
 
   // Prepare data.
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  0,
+                                  kuint64max,
+                                  base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   ASSERT_EQ(OK, init_callback1.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
@@ skipping 19 matching lines @@
   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));
   TestCompletionCallback test_callback;
 
   // Prepare data.
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  0,
+                                  kuint64max,
+                                  base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
   EXPECT_FALSE(stream.IsEOF());
   EXPECT_EQ(kTestDataSize*2, stream.size());
@@ skipping 16 matching lines @@
 TEST_F(UploadDataStreamTest, InitToReset) {
   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));
 
   // Prepare data.
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  0,
+                                  kuint64max,
+                                  base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
@@ skipping 31 matching lines @@
 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));
 
   // Prepare data.
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  0,
+                                  kuint64max,
+                                  base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Start Init.
   TestCompletionCallback init_callback1;
   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 
@@ skipping 22 matching lines @@
 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
   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));
 
   // Prepare data.
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  element_readers_.push_back(new UploadFileElementReader(
-      base::MessageLoopProxy::current(),
-      temp_file_path, 0, kuint64max, base::Time()));
+  element_readers_.push_back(
+      new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                  temp_file_path,
+                                  0,
+                                  kuint64max,
+                                  base::Time()));
   UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
                        expected_data.begin() + kTestDataSize);
 
   // Call Init().
   TestCompletionCallback init_callback1;
   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
@@ skipping 24 matching lines @@
                 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