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

chrome/browser/chromeos/drive/resource_metadata.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/resource_metadata.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
@@ skipping 121 matching lines @@
       storage_(new ResourceMetadataStorage(data_directory_path)),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void ResourceMetadata::Initialize(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::InitializeOnBlockingPool,
                  base::Unretained(this)),
       callback);
 }
 
 void ResourceMetadata::Destroy() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   weak_ptr_factory_.InvalidateWeakPtrs();
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ResourceMetadata::DestroyOnBlockingPool,
                  base::Unretained(this)));
 }
 
 void ResourceMetadata::ResetOnUIThread(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
-      base::Bind(&ResourceMetadata::Reset,
-                 base::Unretained(this)),
+      base::Bind(&ResourceMetadata::Reset, base::Unretained(this)),
       callback);
 }
 
 FileError ResourceMetadata::Reset() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FILE_ERROR_NO_SPACE;
 
   if (!storage_->SetLargestChangestamp(0) ||
@@ skipping 47 matching lines @@
 void ResourceMetadata::DestroyOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   delete this;
 }
 
 void ResourceMetadata::GetLargestChangestampOnUIThread(
     const GetChangestampCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetLargestChangestamp,
                  base::Unretained(this)),
       callback);
 }
 
 void ResourceMetadata::SetLargestChangestampOnUIThread(
     int64 value,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::SetLargestChangestamp,
                  base::Unretained(this),
                  value),
       callback);
 }
 
 int64 ResourceMetadata::GetLargestChangestamp() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   return storage_->GetLargestChangestamp();
 }
 
 FileError ResourceMetadata::SetLargestChangestamp(int64 value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FILE_ERROR_NO_SPACE;
 
   storage_->SetLargestChangestamp(value);
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::AddEntryOnUIThread(const ResourceEntry& entry,
                                           const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  PostFileMoveTask(blocking_task_runner_,
-                   base::Bind(&AddEntryWithFilePath,
-                              base::Unretained(this),
-                              entry),
-                   callback);
+  PostFileMoveTask(
+      blocking_task_runner_.get(),
+      base::Bind(&AddEntryWithFilePath, base::Unretained(this), entry),
+      callback);
 }
 
 FileError ResourceMetadata::AddEntry(const ResourceEntry& entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
     return FILE_ERROR_NO_SPACE;
 
   scoped_ptr<ResourceEntry> existing_entry =
       storage_->GetEntry(entry.resource_id());
@@ skipping 11 matching lines @@
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::MoveEntryToDirectoryOnUIThread(
     const base::FilePath& file_path,
     const base::FilePath& directory_path,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  PostFileMoveTask(blocking_task_runner_,
+  PostFileMoveTask(blocking_task_runner_.get(),
                    base::Bind(&ResourceMetadata::MoveEntryToDirectory,
                               base::Unretained(this),
                               file_path,
                               directory_path),
                    callback);
 }
 
 void ResourceMetadata::RenameEntryOnUIThread(const base::FilePath& file_path,
                                              const std::string& new_name,
                                              const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  PostFileMoveTask(blocking_task_runner_,
+  PostFileMoveTask(blocking_task_runner_.get(),
                    base::Bind(&ResourceMetadata::RenameEntry,
                               base::Unretained(this),
                               file_path,
                               new_name),
                    callback);
 }
 
 FileError ResourceMetadata::RemoveEntry(const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 15 matching lines @@
 
 void ResourceMetadata::GetResourceEntryByIdOnUIThread(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<ResourceEntry> entry(new ResourceEntry);
   ResourceEntry* entry_ptr = entry.get();
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetResourceEntryById,
                  base::Unretained(this),
                  resource_id,
                  entry_ptr),
-      base::Bind(&RunGetResourceEntryCallback,
-                 callback,
-                 base::Passed(&entry)));
+      base::Bind(&RunGetResourceEntryCallback, callback, base::Passed(&entry)));
 }
 
 FileError ResourceMetadata::GetResourceEntryById(
     const std::string& resource_id,
     ResourceEntry* out_entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!resource_id.empty());
   DCHECK(out_entry);
 
   scoped_ptr<ResourceEntry> entry = storage_->GetEntry(resource_id);
   if (!entry)
     return FILE_ERROR_NOT_FOUND;
 
   out_entry->Swap(entry.get());
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::GetResourceEntryByPathOnUIThread(
     const base::FilePath& file_path,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<ResourceEntry> entry(new ResourceEntry);
   ResourceEntry* entry_ptr = entry.get();
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetResourceEntryByPath,
                  base::Unretained(this),
                  file_path,
                  entry_ptr),
-      base::Bind(&RunGetResourceEntryCallback,
-                 callback,
-                 base::Passed(&entry)));
+      base::Bind(&RunGetResourceEntryCallback, callback, base::Passed(&entry)));
 }
 
 FileError ResourceMetadata::GetResourceEntryByPath(const base::FilePath& path,
                                                    ResourceEntry* out_entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(out_entry);
 
   scoped_ptr<ResourceEntry> entry = FindEntryByPathSync(path);
   if (!entry)
     return FILE_ERROR_NOT_FOUND;
 
   *out_entry = *entry;
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::ReadDirectoryByPathOnUIThread(
     const base::FilePath& file_path,
     const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<ResourceEntryVector> entries(new ResourceEntryVector);
   ResourceEntryVector* entries_ptr = entries.get();
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::ReadDirectoryByPath,
                  base::Unretained(this),
                  file_path,
                  entries_ptr),
-      base::Bind(&RunReadDirectoryCallback,
-                 callback,
-                 base::Passed(&entries)));
+      base::Bind(&RunReadDirectoryCallback, callback, base::Passed(&entries)));
 }
 
 FileError ResourceMetadata::ReadDirectoryByPath(
     const base::FilePath& path,
     ResourceEntryVector* out_entries) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(out_entries);
 
   scoped_ptr<ResourceEntry> entry = FindEntryByPathSync(path);
   if (!entry)
@@ skipping 45 matching lines @@
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::RefreshDirectoryOnUIThread(
     const DirectoryFetchInfo& directory_fetch_info,
     const ResourceEntryMap& entry_map,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  PostFileMoveTask(blocking_task_runner_,
+  PostFileMoveTask(blocking_task_runner_.get(),
                    base::Bind(&ResourceMetadata::RefreshDirectory,
                               base::Unretained(this),
                               directory_fetch_info,
                               entry_map),
                    callback);
 }
 
 void ResourceMetadata::GetChildDirectories(
     const std::string& resource_id,
     std::set<base::FilePath>* child_directories) {
@@ skipping 316 matching lines @@
     for (size_t i = 0; i < children.size(); ++i) {
       if (!RemoveEntryRecursively(children[i]))
         return false;
     }
   }
   return storage_->RemoveEntry(resource_id);
 }
 
 }  // namespace internal
 }  // namespace drive