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

chrome/browser/chromeos/drive/drive_file_stream_reader_unittest.cc

 // Copyright 2013 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/chromeos/drive/drive_file_stream_reader.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 45 matching lines @@
   base::ScopedTempDir temp_dir_;
   base::FilePath file_path_;
   std::string file_content_;
 
   scoped_ptr<base::Thread> worker_thread_;
 };
 
 TEST_F(LocalReaderProxyTest, Read) {
   // Open the file first.
   scoped_ptr<util::LocalFileReader> file_reader(
-      new util::LocalFileReader(worker_thread_->message_loop_proxy()));
+      new util::LocalFileReader(worker_thread_->message_loop_proxy().get()));
   net::TestCompletionCallback callback;
   file_reader->Open(file_path_, 0, callback.callback());
   ASSERT_EQ(net::OK, callback.WaitForResult());
 
   // Test instance.
   LocalReaderProxy proxy(file_reader.Pass(), file_content_.size());
 
   // Make sure the read content is as same as the file.
   std::string content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(&proxy, &content));
   EXPECT_EQ(file_content_, content);
 }
 
 TEST_F(LocalReaderProxyTest, ReadWithLimit) {
   // This test case, we only read first half of the file.
   const std::string expected_content =
       file_content_.substr(0, file_content_.size() / 2);
 
   // Open the file first.
   scoped_ptr<util::LocalFileReader> file_reader(
-      new util::LocalFileReader(worker_thread_->message_loop_proxy()));
+      new util::LocalFileReader(worker_thread_->message_loop_proxy().get()));
   net::TestCompletionCallback callback;
   file_reader->Open(file_path_, 0, callback.callback());
   ASSERT_EQ(net::OK, callback.WaitForResult());
 
   // Test instance.
   LocalReaderProxy proxy(file_reader.Pass(), expected_content.size());
 
   // Make sure the read content is as same as the file.
   std::string content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(&proxy, &content));
@@ skipping 225 matching lines @@
   scoped_ptr<FakeDriveService> fake_drive_service_;
   scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
 };
 
 TEST_F(DriveFileStreamReaderTest, Read) {
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
-      GetFileSystemGetter(),
-      worker_thread_->message_loop_proxy()));
+      GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
   scoped_ptr<ResourceEntry> entry;
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         net::HttpByteRange(),
         google_apis::test_util::CreateQuitCallback(
             &run_loop,
             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
     run_loop.Run();
   }
   EXPECT_EQ(net::OK, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(reader->IsInitialized());
   size_t content_size = entry->file_info().size();
 
   // Read data from the reader.
   std::string first_content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &first_content));
   EXPECT_EQ(content_size, first_content.size());
 
   // Create second instance and initialize it.
   // In this case, the file should be cached one.
-  reader.reset(
-      new DriveFileStreamReader(GetFileSystemGetter(),
-                                worker_thread_->message_loop_proxy()));
+  reader.reset(new DriveFileStreamReader(
+      GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   error = net::ERR_FAILED;
   entry.reset();
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         net::HttpByteRange(),
         google_apis::test_util::CreateQuitCallback(
@@ skipping 19 matching lines @@
 TEST_F(DriveFileStreamReaderTest, ReadRange) {
   // In this test case, we just confirm that the part of file is read.
   const int64 kRangeOffset = 3;
   const int64 kRangeLength = 4;
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
-      GetFileSystemGetter(),
-      worker_thread_->message_loop_proxy()));
+      GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
   scoped_ptr<ResourceEntry> entry;
   net::HttpByteRange byte_range;
   byte_range.set_first_byte_position(kRangeOffset);
   // Last byte position is inclusive.
   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
   {
     base::RunLoop run_loop;
@@ skipping 11 matching lines @@
 
   // Read data from the reader.
   std::string first_content;
   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &first_content));
 
   // The length should be equal to range length.
   EXPECT_EQ(kRangeLength, static_cast<int64>(first_content.size()));
 
   // Create second instance and initialize it.
   // In this case, the file should be cached one.
-  reader.reset(
-      new DriveFileStreamReader(GetFileSystemGetter(),
-                                worker_thread_->message_loop_proxy()));
+  reader.reset(new DriveFileStreamReader(
+      GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   error = net::ERR_FAILED;
   entry.reset();
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         byte_range,
         google_apis::test_util::CreateQuitCallback(
@@ skipping 15 matching lines @@
 
 TEST_F(DriveFileStreamReaderTest, OutOfRangeError) {
   const int64 kRangeOffset = 1000000;  // Out of range.
   const int64 kRangeLength = 4;
 
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
   // Create the reader, and initialize it.
   // In this case, the file is not yet locally cached.
   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
-      GetFileSystemGetter(),
-      worker_thread_->message_loop_proxy()));
+      GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
   EXPECT_FALSE(reader->IsInitialized());
 
   int error = net::ERR_FAILED;
   scoped_ptr<ResourceEntry> entry;
   net::HttpByteRange byte_range;
   byte_range.set_first_byte_position(kRangeOffset);
   // Last byte position is inclusive.
   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
   {
     base::RunLoop run_loop;
     reader->Initialize(
         kDriveFile,
         byte_range,
         google_apis::test_util::CreateQuitCallback(
             &run_loop,
             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
     run_loop.Run();
   }
   EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, error);
   EXPECT_FALSE(entry);
 }
 
 }  // namespace drive