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

chrome/browser/chromeos/drive/file_cache_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 "chrome/browser/chromeos/drive/file_cache.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 59 matching lines @@
     ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                     &dummy_file_path_));
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
     metadata_storage_.reset(new ResourceMetadataStorage(
-        temp_dir_.path(), blocking_task_runner_));
+        temp_dir_.path(), blocking_task_runner_.get()));
 
     bool success = false;
     base::PostTaskAndReplyWithResult(
-        blocking_task_runner_,
+        blocking_task_runner_.get(),
         FROM_HERE,
         base::Bind(&ResourceMetadataStorage::Initialize,
                    base::Unretained(metadata_storage_.get())),
         google_apis::test_util::CreateCopyResultCallback(&success));
     google_apis::test_util::RunBlockingPoolTask();
     ASSERT_TRUE(success);
 
     cache_.reset(new FileCache(
         metadata_storage_.get(),
         temp_dir_.path().Append(util::kCacheFileDirectory),
         blocking_task_runner_.get(),
         fake_free_disk_space_getter_.get()));
 
     success = false;
     base::PostTaskAndReplyWithResult(
-        blocking_task_runner_,
+        blocking_task_runner_.get(),
         FROM_HERE,
-        base::Bind(&FileCache::Initialize,
-                   base::Unretained(cache_.get())),
+        base::Bind(&FileCache::Initialize, base::Unretained(cache_.get())),
         google_apis::test_util::CreateCopyResultCallback(&success));
     google_apis::test_util::RunBlockingPoolTask();
     ASSERT_TRUE(success);
   }
 
   void TestGetFileFromCacheByResourceIdAndMd5(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       const std::string& expected_file_extension) {
@@ skipping 777 matching lines @@
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(file_util::CreateDirectory(
         temp_dir_.path().Append(util::kMetadataDirectory)));
     ASSERT_TRUE(file_util::CreateDirectory(
         temp_dir_.path().Append(util::kCacheFileDirectory)));
 
     fake_free_disk_space_getter_.reset(new FakeFreeDiskSpaceGetter);
 
     metadata_storage_.reset(new ResourceMetadataStorage(
         temp_dir_.path().Append(util::kMetadataDirectory),
-        base::MessageLoopProxy::current()));
+        base::MessageLoopProxy::current().get()));
     ASSERT_TRUE(metadata_storage_->Initialize());
 
     cache_.reset(new FileCache(
         metadata_storage_.get(),
         temp_dir_.path().Append(util::kCacheFileDirectory),
-        base::MessageLoopProxy::current(),
+        base::MessageLoopProxy::current().get(),
         fake_free_disk_space_getter_.get()));
     ASSERT_TRUE(cache_->Initialize());
   }
 
   static bool ImportOldDB(FileCache* cache, const base::FilePath& old_db_path) {
     return cache->ImportOldDB(old_db_path);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
@@ skipping 19 matching lines @@
   ASSERT_TRUE(base::Delete(metadata_directory, true /* recursive */));
 
   // Put an empty file with the same name as old DB.
   // This file cannot be opened by ImportOldDB() and will be dismissed.
   ASSERT_TRUE(file_util::CreateDirectory(metadata_directory));
   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(
       metadata_directory.Append(FileCache::kOldCacheMetadataDBName), ""));
 
   // Create a new cache and initialize it.
   metadata_storage_.reset(new ResourceMetadataStorage(
-      metadata_directory, base::MessageLoopProxy::current()));
+      metadata_directory, base::MessageLoopProxy::current().get()));
   ASSERT_TRUE(metadata_storage_->Initialize());
 
   cache_.reset(new FileCache(metadata_storage_.get(),
                              temp_dir_.path().Append(util::kCacheFileDirectory),
-                             base::MessageLoopProxy::current(),
+                             base::MessageLoopProxy::current().get(),
                              fake_free_disk_space_getter_.get()));
   ASSERT_TRUE(cache_->Initialize());
 
   // Check contents of the cache.
   FileCacheEntry cache_entry;
   EXPECT_TRUE(cache_->GetCacheEntry("id_foo", std::string(), &cache_entry));
   EXPECT_TRUE(cache_entry.is_present());
   EXPECT_EQ("md5foo", cache_entry.md5());
 
   EXPECT_TRUE(cache_->GetCacheEntry("id_bar", std::string(), &cache_entry));
@@ skipping 74 matching lines @@
   // Data is imported correctly.
   FileCacheEntry entry;
   EXPECT_TRUE(cache_->GetCacheEntry(key1, std::string(), &entry));
   EXPECT_EQ(md5_1, entry.md5());
   EXPECT_TRUE(cache_->GetCacheEntry(key2, std::string(), &entry));
   EXPECT_EQ(md5_2, entry.md5());
 }
 
 }  // namespace internal
 }  // namespace drive