Remove implicit conversions from scoped_refptr to T* in c/b/chromeos/drive

chrome/browser/chromeos/drive/file_system.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_system.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
@@ skipping 268 matching lines @@
 
 void FileSystem::Reset(const FileOperationCallback& callback) {
   // Discard the current loader and operation objects and renew them. This is to
   // avoid that changes initiated before the metadata reset is applied after the
   // reset, which may cause an inconsistent state.
   // TODO(kinaba): callbacks held in the subcomponents are discarded. We might
   // want to have a way to abort and flush callbacks in in-flight operations.
   ResetComponents();
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResetOnBlockingPool, resource_metadata_, cache_),
       callback);
 }
 
 void FileSystem::ResetComponents() {
   file_system::OperationDelegate* delegate = this;
 
   about_resource_loader_.reset(new internal::AboutResourceLoader(scheduler_));
   loader_controller_.reset(new internal::LoaderController);
@@ skipping 203 matching lines @@
   truncate_operation_->Truncate(file_path, length, callback);
 }
 
 void FileSystem::Pin(const base::FilePath& file_path,
                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   std::string* local_id = new std::string;
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&PinInternal, resource_metadata_, cache_, file_path, local_id),
       base::Bind(&FileSystem::FinishPin,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(local_id)));
 }
 
 void FileSystem::FinishPin(const FileOperationCallback& callback,
                            const std::string* local_id,
                            FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK)
     sync_client_->AddFetchTask(*local_id);
   callback.Run(error);
 }
 
 void FileSystem::Unpin(const base::FilePath& file_path,
                        const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   std::string* local_id = new std::string;
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
-      base::Bind(&UnpinInternal,
-                 resource_metadata_,
-                 cache_,
-                 file_path,
-                 local_id),
+      base::Bind(
+          &UnpinInternal, resource_metadata_, cache_, file_path, local_id),
       base::Bind(&FileSystem::FinishUnpin,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  base::Owned(local_id)));
 }
 
 void FileSystem::FinishUnpin(const FileOperationCallback& callback,
                              const std::string* local_id,
                              FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 64 matching lines @@
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DVLOG_IF(1, error != FILE_ERROR_OK) << "ReadDirectory failed. "
                                       << FileErrorToString(error);
 
   scoped_ptr<ResourceEntry> entry(new ResourceEntry);
   ResourceEntry* entry_ptr = entry.get();
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&GetLocallyStoredResourceEntry,
                  resource_metadata_,
                  cache_,
                  file_path,
                  entry_ptr),
       base::Bind(&RunGetResourceEntryCallback, callback, base::Passed(&entry)));
 }
 
 void FileSystem::ReadDirectory(
@@ skipping 153 matching lines @@
 }
 
 void FileSystem::OnEntryUpdatedByOperation(const std::string& local_id) {
   sync_client_->AddUpdateTask(ClientContext(USER_INITIATED), local_id);
 }
 
 void FileSystem::OnDriveSyncError(file_system::DriveSyncErrorType type,
                                   const std::string& local_id) {
   base::FilePath* file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetFilePath,
                  base::Unretained(resource_metadata_),
                  local_id,
                  file_path),
       base::Bind(&FileSystem::OnDriveSyncErrorAfterGetFilePath,
                  weak_ptr_factory_.GetWeakPtr(),
                  type,
                  base::Owned(file_path)));
 }
@@ skipping 51 matching lines @@
 
   FileSystemMetadata metadata;
   metadata.refreshing = change_list_loader_->IsRefreshing();
 
   // Metadata related to delta update.
   metadata.last_update_check_time = last_update_check_time_;
   metadata.last_update_check_error = last_update_check_error_;
 
   int64* largest_changestamp = new int64(0);
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetLargestChangestamp,
-                 base::Unretained(resource_metadata_), largest_changestamp),
-      base::Bind(&OnGetLargestChangestamp, metadata, callback,
+                 base::Unretained(resource_metadata_),
+                 largest_changestamp),
+      base::Bind(&OnGetLargestChangestamp,
+                 metadata,
+                 callback,
                  base::Owned(largest_changestamp)));
 }
 
 void FileSystem::MarkCacheFileAsMounted(
     const base::FilePath& drive_file_path,
     const MarkMountedCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::FilePath* cache_file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&MarkCacheFileAsMountedInternal,
                  resource_metadata_,
                  cache_,
                  drive_file_path,
                  cache_file_path),
-      base::Bind(&RunMarkMountedCallback,
-                 callback,
-                 base::Owned(cache_file_path)));
+      base::Bind(
+          &RunMarkMountedCallback, callback, base::Owned(cache_file_path)));
 }
 
 void FileSystem::MarkCacheFileAsUnmounted(
     const base::FilePath& cache_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!cache_->IsUnderFileCacheDirectory(cache_file_path)) {
     callback.Run(FILE_ERROR_FAILED);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::FileCache::MarkAsUnmounted,
                  base::Unretained(cache_),
                  cache_file_path),
       callback);
 }
 
 void FileSystem::AddPermission(const base::FilePath& drive_file_path,
                                const std::string& email,
                                google_apis::drive::PermissionRole role,
@@ skipping 48 matching lines @@
   open_file_operation_->OpenFile(file_path, open_mode, mime_type, callback);
 }
 
 void FileSystem::GetPathFromResourceId(const std::string& resource_id,
                                        const GetFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::FilePath* const file_path = new base::FilePath();
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&GetPathFromResourceIdOnBlockingPool,
                  resource_metadata_,
                  resource_id,
                  file_path),
       base::Bind(&GetPathFromResourceIdAfterGetPath,
                  base::Owned(file_path),
                  callback));
 }
 }  // namespace drive