Remove implicit conversions from scoped_refptr to T* in chrome/browser/sync_file_system/

chrome/browser/sync_file_system/local/canned_syncable_file_system.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/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 217 matching lines @@
 void CannedSyncableFileSystem::SetUp(QuotaMode quota_mode) {
   ASSERT_FALSE(is_filesystem_set_up_);
   ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
   scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
       new content::MockSpecialStoragePolicy();
 
   if (quota_mode == QUOTA_ENABLED) {
     quota_manager_ = new QuotaManager(false /* is_incognito */,
                                       data_dir_.path(),
-                                      io_task_runner_,
+                                      io_task_runner_.get(),
                                       base::ThreadTaskRunnerHandle::Get().get(),
                                       storage_policy.get());
   }
 
   std::vector<std::string> additional_allowed_schemes;
   additional_allowed_schemes.push_back(origin_.scheme());
   storage::FileSystemOptions options(
       storage::FileSystemOptions::PROFILE_MODE_NORMAL,
       additional_allowed_schemes,
       env_override_);
 
   ScopedVector<storage::FileSystemBackend> additional_backends;
   additional_backends.push_back(SyncFileSystemBackend::CreateForTesting());
 
   file_system_context_ = new FileSystemContext(
-      io_task_runner_,
-      file_task_runner_,
+      io_task_runner_.get(),
+      file_task_runner_.get(),
       storage::ExternalMountPoints::CreateRefCounted().get(),
       storage_policy.get(),
-      quota_manager_ ? quota_manager_->proxy() : NULL,
+      quota_manager_.get() ? quota_manager_->proxy() : NULL,
       additional_backends.Pass(),
       std::vector<storage::URLRequestAutoMountHandler>(),
       data_dir_.path(),
       options);
 
   is_filesystem_set_up_ = true;
 }
 
 void CannedSyncableFileSystem::TearDown() {
   quota_manager_ = NULL;
   file_system_context_ = NULL;
 
   // Make sure we give some more time to finish tasks on other threads.
-  EnsureLastTaskRuns(io_task_runner_);
-  EnsureLastTaskRuns(file_task_runner_);
+  EnsureLastTaskRuns(io_task_runner_.get());
+  EnsureLastTaskRuns(file_task_runner_.get());
 }
 
 FileSystemURL CannedSyncableFileSystem::URL(const std::string& path) const {
   EXPECT_TRUE(is_filesystem_set_up_);
   EXPECT_FALSE(root_url_.is_empty());
 
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
 File::Error CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
 
   base::RunLoop run_loop;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoOpenFileSystem,
                  base::Unretained(this),
                  base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                             base::Unretained(this),
                             base::ThreadTaskRunnerHandle::Get(),
                             run_loop.QuitClosure())));
   run_loop.Run();
 
   if (backend()->sync_context()) {
     // Register 'this' as a sync status observer.
     RunOnThread(
-        io_task_runner_,
+        io_task_runner_.get(),
         FROM_HERE,
         base::Bind(&CannedSyncableFileSystem::InitializeSyncStatusObserver,
                    base::Unretained(this)));
   }
   return result_;
 }
 
 void CannedSyncableFileSystem::AddSyncStatusObserver(
     LocalFileSyncStatus::Observer* observer) {
   sync_status_observers_->AddObserver(observer);
 }
 
 void CannedSyncableFileSystem::RemoveSyncStatusObserver(
     LocalFileSyncStatus::Observer* observer) {
   sync_status_observers_->RemoveObserver(observer);
 }
 
 SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext(
     LocalFileSyncContext* sync_context) {
   DCHECK(sync_context);
   base::RunLoop run_loop;
   sync_status_ = sync_file_system::SYNC_STATUS_UNKNOWN;
-  VerifySameTaskRunner(io_task_runner_,
-                       sync_context->io_task_runner_);
+  VerifySameTaskRunner(io_task_runner_.get(),
+                       sync_context->io_task_runner_.get());
   sync_context->MaybeInitializeFileSystemContext(
       origin_,
       file_system_context_.get(),
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this),
                  run_loop.QuitClosure()));
   run_loop.Run();
   return sync_status_;
 }
 
 File::Error CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateDirectory,
                  base::Unretained(this),
                  url));
 }
 
 File::Error CannedSyncableFileSystem::CreateFile(const FileSystemURL& url) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateFile,
                  base::Unretained(this),
                  url));
 }
 
 File::Error CannedSyncableFileSystem::Copy(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
-  return RunOnThread<File::Error>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoCopy,
-                 base::Unretained(this),
-                 src_url,
-                 dest_url));
+  return RunOnThread<File::Error>(io_task_runner_.get(),
+                                  FROM_HERE,
+                                  base::Bind(&CannedSyncableFileSystem::DoCopy,
+                                             base::Unretained(this),
+                                             src_url,
+                                             dest_url));
 }
 
 File::Error CannedSyncableFileSystem::Move(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
-  return RunOnThread<File::Error>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoMove,
-                 base::Unretained(this),
-                 src_url,
-                 dest_url));
+  return RunOnThread<File::Error>(io_task_runner_.get(),
+                                  FROM_HERE,
+                                  base::Bind(&CannedSyncableFileSystem::DoMove,
+                                             base::Unretained(this),
+                                             src_url,
+                                             dest_url));
 }
 
 File::Error CannedSyncableFileSystem::TruncateFile(
     const FileSystemURL& url, int64 size) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTruncateFile,
                  base::Unretained(this),
                  url,
                  size));
 }
 
 File::Error CannedSyncableFileSystem::TouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTouchFile,
                  base::Unretained(this),
                  url,
                  last_access_time,
                  last_modified_time));
 }
 
 File::Error CannedSyncableFileSystem::Remove(
     const FileSystemURL& url, bool recursive) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoRemove,
                  base::Unretained(this),
                  url,
                  recursive));
 }
 
 File::Error CannedSyncableFileSystem::FileExists(
     const FileSystemURL& url) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoFileExists,
                  base::Unretained(this),
                  url));
 }
 
 File::Error CannedSyncableFileSystem::DirectoryExists(
     const FileSystemURL& url) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoDirectoryExists,
                  base::Unretained(this),
                  url));
 }
 
 File::Error CannedSyncableFileSystem::VerifyFile(
     const FileSystemURL& url,
     const std::string& expected_data) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoVerifyFile,
                  base::Unretained(this),
                  url,
                  expected_data));
 }
 
 File::Error CannedSyncableFileSystem::GetMetadataAndPlatformPath(
     const FileSystemURL& url,
     base::File::Info* info,
     base::FilePath* platform_path) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetMetadataAndPlatformPath,
                  base::Unretained(this),
                  url,
                  info,
                  platform_path));
 }
 
 File::Error CannedSyncableFileSystem::ReadDirectory(
     const storage::FileSystemURL& url,
     FileEntryList* entries) {
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoReadDirectory,
-          base::Unretained(this),
-          url,
-          entries));
+                 base::Unretained(this),
+                 url,
+                 entries));
 }
 
 int64 CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
-  return RunOnThread<int64>(io_task_runner_,
+  return RunOnThread<int64>(io_task_runner_.get(),
                             FROM_HERE,
                             base::Bind(&CannedSyncableFileSystem::DoWrite,
                                        base::Unretained(this),
                                        url_request_context,
                                        url,
                                        base::Passed(&blob_data_handle)));
 }
 
 int64 CannedSyncableFileSystem::WriteString(
     const FileSystemURL& url, const std::string& data) {
-  return RunOnThread<int64>(io_task_runner_,
+  return RunOnThread<int64>(io_task_runner_.get(),
                             FROM_HERE,
                             base::Bind(&CannedSyncableFileSystem::DoWriteString,
                                        base::Unretained(this),
                                        url,
                                        data));
 }
 
 File::Error CannedSyncableFileSystem::DeleteFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   return RunOnThread<File::Error>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
                  file_system_context_,
                  origin_,
                  type_));
 }
 
 storage::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
     int64* usage,
     int64* quota) {
   return RunOnThread<storage::QuotaStatusCode>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota,
                  base::Unretained(this),
                  usage,
                  quota));
 }
 
 void CannedSyncableFileSystem::GetChangedURLsInTracker(
     FileSystemURLSet* urls) {
-  RunOnThread(
-      file_task_runner_,
-      FROM_HERE,
-      base::Bind(&LocalFileChangeTracker::GetAllChangedURLs,
-                 base::Unretained(backend()->change_tracker()),
-                 urls));
+  RunOnThread(file_task_runner_.get(),
+              FROM_HERE,
+              base::Bind(&LocalFileChangeTracker::GetAllChangedURLs,
+                         base::Unretained(backend()->change_tracker()),
+                         urls));
 }
 
 void CannedSyncableFileSystem::ClearChangeForURLInTracker(
     const FileSystemURL& url) {
-  RunOnThread(
-      file_task_runner_,
-      FROM_HERE,
-      base::Bind(&LocalFileChangeTracker::ClearChangesForURL,
-                 base::Unretained(backend()->change_tracker()),
-                 url));
+  RunOnThread(file_task_runner_.get(),
+              FROM_HERE,
+              base::Bind(&LocalFileChangeTracker::ClearChangesForURL,
+                         base::Unretained(backend()->change_tracker()),
+                         url));
 }
 
 void CannedSyncableFileSystem::GetChangesForURLInTracker(
     const FileSystemURL& url,
     FileChangeList* changes) {
-  RunOnThread(
-      file_task_runner_,
-      FROM_HERE,
-      base::Bind(&LocalFileChangeTracker::GetChangesForURL,
-                 base::Unretained(backend()->change_tracker()),
-                 url, changes));
+  RunOnThread(file_task_runner_.get(),
+              FROM_HERE,
+              base::Bind(&LocalFileChangeTracker::GetChangesForURL,
+                         base::Unretained(backend()->change_tracker()),
+                         url,
+                         changes));
 }
 
 SyncFileSystemBackend* CannedSyncableFileSystem::backend() {
-  return SyncFileSystemBackend::GetBackend(file_system_context_);
+  return SyncFileSystemBackend::GetBackend(file_system_context_.get());
 }
 
 FileSystemOperationRunner* CannedSyncableFileSystem::operation_runner() {
   return file_system_context_->operation_runner();
 }
 
 void CannedSyncableFileSystem::OnSyncEnabled(const FileSystemURL& url) {
   sync_status_observers_->Notify(&LocalFileSyncStatus::Observer::OnSyncEnabled,
                                  url);
 }
@@ skipping 156 matching lines @@
                             base::Bind(&WriteHelper::DidWrite,
                                        base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoGetUsageAndQuota(
     int64* usage,
     int64* quota,
     const storage::StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
-  DCHECK(quota_manager_);
+  DCHECK(quota_manager_.get());
   quota_manager_->GetUsageAndQuota(
       origin_, storage_type(),
       base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
 }
 
 void CannedSyncableFileSystem::DidOpenFileSystem(
     base::SingleThreadTaskRunner* original_task_runner,
     const base::Closure& quit_closure,
     const GURL& root,
     const std::string& name,
@@ skipping 24 matching lines @@
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system