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

webkit/browser/fileapi/syncable/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 "webkit/browser/fileapi/syncable/canned_syncable_file_system.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 183 matching lines @@
 
 CannedSyncableFileSystem::~CannedSyncableFileSystem() {}
 
 void CannedSyncableFileSystem::SetUp() {
   ASSERT_FALSE(is_filesystem_set_up_);
   ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
   scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
       new quota::MockSpecialStoragePolicy();
 
-  quota_manager_ = new QuotaManager(
-      false /* is_incognito */,
-      data_dir_.path(),
-      io_task_runner_,
-      base::MessageLoopProxy::current(),
-      storage_policy);
+  quota_manager_ = new QuotaManager(false /* is_incognito */,
+                                    data_dir_.path(),
+                                    io_task_runner_.get(),
+                                    base::MessageLoopProxy::current(),
+                                    storage_policy.get());
 
   file_system_context_ = new FileSystemContext(
-      make_scoped_ptr(new fileapi::FileSystemTaskRunners(
-          io_task_runner_,
-          file_task_runner_,
-          file_task_runner_)),
+      make_scoped_ptr(
+          new fileapi::FileSystemTaskRunners(io_task_runner_.get(),
+                                             file_task_runner_.get(),
+                                             file_task_runner_.get())),
       fileapi::ExternalMountPoints::CreateRefCounted().get(),
-      storage_policy,
+      storage_policy.get(),
       quota_manager_->proxy(),
       ScopedVector<fileapi::FileSystemMountPointProvider>(),
       data_dir_.path(),
       fileapi::CreateAllowFileAccessOptions());
 
   // In testing we override this setting to support directory operations
   // by default.
   SetEnableSyncFSDirectoryOperation(true);
 
   is_filesystem_set_up_ = true;
 }
 
 void CannedSyncableFileSystem::TearDown() {
   quota_manager_ = NULL;
   file_system_context_ = NULL;
   SetEnableSyncFSDirectoryOperation(false);
 
   // 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_TRUE(is_filesystem_opened_);
 
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
 PlatformFileError CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   EXPECT_FALSE(is_filesystem_opened_);
   file_system_context_->OpenSyncableFileSystem(
       service_name_, origin_, type_,
       fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   if (file_system_context_->sync_context()) {
     // Register 'this' as a sync status observer.
-    RunOnThread(io_task_runner_,
-                FROM_HERE,
-                base::Bind(
-                    &CannedSyncableFileSystem::InitializeSyncStatusObserver,
-                    base::Unretained(this)));
+    RunOnThread(
+        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);
   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_, service_name_, file_system_context_,
+      origin_,
+      service_name_,
+      file_system_context_.get(),
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   return sync_status_;
 }
 
 PlatformFileError CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateDirectory,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::CreateFile(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateFile,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::Copy(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCopy,
-                 base::Unretained(this), src_url, dest_url));
+                 base::Unretained(this),
+                 src_url,
+                 dest_url));
 }
 
 PlatformFileError CannedSyncableFileSystem::Move(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoMove,
-                 base::Unretained(this), src_url, dest_url));
+                 base::Unretained(this),
+                 src_url,
+                 dest_url));
 }
 
 PlatformFileError CannedSyncableFileSystem::TruncateFile(
     const FileSystemURL& url, int64 size) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTruncateFile,
-                 base::Unretained(this), url, size));
+                 base::Unretained(this),
+                 url,
+                 size));
 }
 
 PlatformFileError CannedSyncableFileSystem::TouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTouchFile,
-                 base::Unretained(this), url,
-                 last_access_time, last_modified_time));
+                 base::Unretained(this),
+                 url,
+                 last_access_time,
+                 last_modified_time));
 }
 
 PlatformFileError CannedSyncableFileSystem::Remove(
     const FileSystemURL& url, bool recursive) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoRemove,
-                 base::Unretained(this), url, recursive));
+                 base::Unretained(this),
+                 url,
+                 recursive));
 }
 
 PlatformFileError CannedSyncableFileSystem::FileExists(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoFileExists,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::DirectoryExists(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoDirectoryExists,
-                 base::Unretained(this), url));
+                 base::Unretained(this),
+                 url));
 }
 
 PlatformFileError CannedSyncableFileSystem::VerifyFile(
     const FileSystemURL& url,
     const std::string& expected_data) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoVerifyFile,
-                 base::Unretained(this), url, expected_data));
+                 base::Unretained(this),
+                 url,
+                 expected_data));
 }
 
 PlatformFileError CannedSyncableFileSystem::GetMetadata(
     const FileSystemURL& url,
     base::PlatformFileInfo* info,
     base::FilePath* platform_path) {
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetMetadata,
-                 base::Unretained(this), url, info, platform_path));
+                 base::Unretained(this),
+                 url,
+                 info,
+                 platform_path));
 }
 
 int64 CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url, const GURL& blob_url) {
-  return RunOnThread<int64>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoWrite,
-                 base::Unretained(this), url_request_context, url, blob_url));
+  return RunOnThread<int64>(io_task_runner_.get(),
+                            FROM_HERE,
+                            base::Bind(&CannedSyncableFileSystem::DoWrite,
+                                       base::Unretained(this),
+                                       url_request_context,
+                                       url,
+                                       blob_url));
 }
 
 int64 CannedSyncableFileSystem::WriteString(
     const FileSystemURL& url, const std::string& data) {
-  return RunOnThread<int64>(
-      io_task_runner_,
-      FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoWriteString,
-                 base::Unretained(this), url, data));
+  return RunOnThread<int64>(io_task_runner_.get(),
+                            FROM_HERE,
+                            base::Bind(&CannedSyncableFileSystem::DoWriteString,
+                                       base::Unretained(this),
+                                       url,
+                                       data));
 }
 
 PlatformFileError CannedSyncableFileSystem::DeleteFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   return RunOnThread<PlatformFileError>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
-                 file_system_context_, origin_, type_));
+                 file_system_context_,
+                 origin_,
+                 type_));
 }
 
 quota::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
     int64* usage, int64* quota) {
   return RunOnThread<quota::QuotaStatusCode>(
-      io_task_runner_,
+      io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota,
-                 base::Unretained(this), usage, quota));
+                 base::Unretained(this),
+                 usage,
+                 quota));
 }
 
 void CannedSyncableFileSystem::GetChangedURLsInTracker(
     FileSystemURLSet* urls) {
   return RunOnThread(
-      file_task_runner_,
+      file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&LocalFileChangeTracker::GetAllChangedURLs,
                  base::Unretained(file_system_context_->change_tracker()),
                  urls));
 }
 
 void CannedSyncableFileSystem::ClearChangeForURLInTracker(
     const FileSystemURL& url) {
   return RunOnThread(
-      file_task_runner_,
+      file_task_runner_.get(),
       FROM_HERE,
       base::Bind(&LocalFileChangeTracker::ClearChangesForURL,
                  base::Unretained(file_system_context_->change_tracker()),
                  url));
 }
 
 FileSystemOperation* CannedSyncableFileSystem::NewOperation() {
   return file_system_context_->CreateFileSystemOperation(URL(std::string()),
                                                          NULL);
 }
@@ skipping 104 matching lines @@
   NewOperation()->Write(url_request_context, url, blob_url, 0,
                         base::Bind(&WriteHelper::DidWrite,
                                    base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoWriteString(
     const FileSystemURL& url,
     const std::string& data,
     const WriteCallback& callback) {
   MockBlobURLRequestContext* url_request_context(
-      new MockBlobURLRequestContext(file_system_context_));
+      new MockBlobURLRequestContext(file_system_context_.get()));
   const GURL blob_url(std::string("blob:") + data);
   WriteHelper* helper = new WriteHelper(url_request_context, blob_url, data);
   NewOperation()->Write(url_request_context, url, blob_url, 0,
                         base::Bind(&WriteHelper::DidWrite,
                                    base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoGetUsageAndQuota(
     int64* usage,
     int64* quota,
@@ skipping 16 matching lines @@
   sync_status_ = status;
   base::MessageLoop::current()->Quit();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   file_system_context_->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system