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

chrome/browser/chromeos/drive/file_cache.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 <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
@@ skipping 270 matching lines @@
 }  // namespace
 
 FileCache::FileCache(const base::FilePath& cache_root_path,
                      base::SequencedTaskRunner* blocking_task_runner,
                      FreeDiskSpaceGetterInterface* free_disk_space_getter)
     : cache_root_path_(cache_root_path),
       cache_paths_(GetCachePaths(cache_root_path_)),
       blocking_task_runner_(blocking_task_runner),
       free_disk_space_getter_(free_disk_space_getter),
       weak_ptr_factory_(this) {
-  DCHECK(blocking_task_runner_);
+  DCHECK(blocking_task_runner_.get());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FileCache::~FileCache() {
   // Must be on the sequenced worker pool, as |metadata_| must be deleted on
   // the sequenced worker pool.
   AssertOnSequencedWorkerPool();
 }
 
 base::FilePath FileCache::GetCacheDirectoryPath(
@@ skipping 27 matching lines @@
   if (file_origin == CACHED_FILE_MOUNTED) {
     DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT);
     base_name += base::FilePath::kExtensionSeparator;
     base_name += util::kMountedArchiveFileExtension;
   }
   return GetCacheDirectoryPath(sub_dir_type).Append(
       base::FilePath::FromUTF8Unsafe(base_name));
 }
 
 void FileCache::AssertOnSequencedWorkerPool() {
-  DCHECK(!blocking_task_runner_ ||
+  DCHECK(!blocking_task_runner_.get() ||
          blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
 bool FileCache::IsUnderFileCacheDirectory(const base::FilePath& path) const {
   return cache_root_path_ == path || cache_root_path_.IsParent(path);
 }
 
 void FileCache::GetCacheEntryOnUIThread(const std::string& resource_id,
                                         const std::string& md5,
                                         const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileCacheEntry* cache_entry = new FileCacheEntry;
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::GetCacheEntry,
-                 base::Unretained(this), resource_id, md5, cache_entry),
-      base::Bind(&RunGetCacheEntryCallback,
-                 callback, base::Owned(cache_entry)));
+                 base::Unretained(this),
+                 resource_id,
+                 md5,
+                 cache_entry),
+      base::Bind(
+          &RunGetCacheEntryCallback, callback, base::Owned(cache_entry)));
 }
 
 bool FileCache::GetCacheEntry(const std::string& resource_id,
                               const std::string& md5,
                               FileCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
   return metadata_->GetCacheEntry(resource_id, entry) &&
       CheckIfMd5Matches(md5, *entry);
 }
@@ skipping 23 matching lines @@
   DCHECK(!it->HasError());
 }
 
 void FileCache::FreeDiskSpaceIfNeededForOnUIThread(
     int64 num_bytes,
     const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  num_bytes),
       callback);
 }
 
 bool FileCache::FreeDiskSpaceIfNeededFor(int64 num_bytes) {
   AssertOnSequencedWorkerPool();
 
@@ skipping 19 matching lines @@
   return HasEnoughSpaceFor(num_bytes, cache_root_path_);
 }
 
 void FileCache::GetFileOnUIThread(const std::string& resource_id,
                                   const std::string& md5,
                                   const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::FilePath* cache_file_path = new base::FilePath;
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
-      FROM_HERE,
-      base::Bind(&FileCache::GetFile,
-                 base::Unretained(this), resource_id, md5, cache_file_path),
-      base::Bind(&RunGetFileFromCacheCallback,
-                 callback, base::Owned(cache_file_path)));
+  base::PostTaskAndReplyWithResult(blocking_task_runner_.get(),
+                                   FROM_HERE,
+                                   base::Bind(&FileCache::GetFile,
+                                              base::Unretained(this),
+                                              resource_id,
+                                              md5,
+                                              cache_file_path),
+                                   base::Bind(&RunGetFileFromCacheCallback,
+                                              callback,
+                                              base::Owned(cache_file_path)));
 }
 
 FileError FileCache::GetFile(const std::string& resource_id,
                              const std::string& md5,
                              base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
 
   FileCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry) ||
@@ skipping 17 matching lines @@
 }
 
 void FileCache::StoreOnUIThread(const std::string& resource_id,
                                 const std::string& md5,
                                 const base::FilePath& source_path,
                                 FileOperationType file_operation_type,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
-      FROM_HERE,
-      base::Bind(&FileCache::Store,
-                 base::Unretained(this),
-                 resource_id, md5, source_path, file_operation_type),
-      callback);
+  base::PostTaskAndReplyWithResult(blocking_task_runner_.get(),
+                                   FROM_HERE,
+                                   base::Bind(&FileCache::Store,
+                                              base::Unretained(this),
+                                              resource_id,
+                                              md5,
+                                              source_path,
+                                              file_operation_type),
+                                   callback);
 }
 
 FileError FileCache::Store(const std::string& resource_id,
                            const std::string& md5,
                            const base::FilePath& source_path,
                            FileOperationType file_operation_type) {
   AssertOnSequencedWorkerPool();
   return StoreInternal(resource_id, md5, source_path, file_operation_type);
 }
 
 void FileCache::PinOnUIThread(const std::string& resource_id,
                               const std::string& md5,
                               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(&FileCache::Pin, base::Unretained(this), resource_id, md5),
       callback);
 }
 
 FileError FileCache::Pin(const std::string& resource_id,
                          const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   bool is_persistent = true;
@@ skipping 36 matching lines @@
   return FILE_ERROR_OK;
 }
 
 void FileCache::UnpinOnUIThread(const std::string& resource_id,
                                 const std::string& md5,
                                 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(&FileCache::Unpin, base::Unretained(this), resource_id, md5),
       callback);
 }
 
 FileError FileCache::Unpin(const std::string& resource_id,
                            const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // Unpinning a file means its entry must exist in cache.
@@ skipping 51 matching lines @@
 }
 
 void FileCache::MarkAsMountedOnUIThread(
     const std::string& resource_id,
     const GetFileFromCacheCallback& 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(&FileCache::MarkAsMounted,
-                 base::Unretained(this), resource_id, cache_file_path),
-      base::Bind(RunGetFileFromCacheCallback,
-                 callback, base::Owned(cache_file_path)));
+                 base::Unretained(this),
+                 resource_id,
+                 cache_file_path),
+      base::Bind(
+          RunGetFileFromCacheCallback, callback, base::Owned(cache_file_path)));
 }
 
 void FileCache::MarkAsUnmountedOnUIThread(
     const base::FilePath& file_path,
     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(&FileCache::MarkAsUnmounted,
-                 base::Unretained(this), file_path),
+      base::Bind(
+          &FileCache::MarkAsUnmounted, base::Unretained(this), file_path),
       callback);
 }
 
 void FileCache::MarkDirtyOnUIThread(const std::string& resource_id,
                                     const std::string& md5,
                                     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(&FileCache::MarkDirty,
-                 base::Unretained(this), resource_id, md5),
+      base::Bind(
+          &FileCache::MarkDirty, base::Unretained(this), resource_id, md5),
       callback);
 }
 
 FileError FileCache::MarkDirty(const std::string& resource_id,
                                const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
@@ skipping 100 matching lines @@
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
 void FileCache::RemoveOnUIThread(const std::string& resource_id,
                                  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(&FileCache::Remove,
-                 base::Unretained(this), resource_id),
+      base::Bind(&FileCache::Remove, base::Unretained(this), resource_id),
       callback);
 }
 
 FileError FileCache::Remove(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   // MD5 is not passed into RemoveCacheEntry because we would delete all
   // cache files corresponding to <resource_id> regardless of the md5.
   // So, search for entry in cache without taking md5 into account.
   FileCacheEntry cache_entry;
@@ skipping 38 matching lines @@
   metadata_->RemoveCacheEntry(resource_id);
 
   return FILE_ERROR_OK;
 }
 
 void FileCache::ClearAllOnUIThread(const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::ClearAll, base::Unretained(this)),
       callback);
 }
 
 void FileCache::RequestInitialize(const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
+      blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileCache::InitializeOnBlockingPool, base::Unretained(this)),
       callback);
 }
 
 void FileCache::Destroy() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Invalidate the weak pointer.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Destroy myself on the blocking pool.
   // Note that base::DeletePointer<> cannot be used as the destructor of this
   // class is private.
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FileCache::DestroyOnBlockingPool, base::Unretained(this)));
 }
 
 bool FileCache::InitializeOnBlockingPool() {
   AssertOnSequencedWorkerPool();
 
   if (!InitCachePaths(cache_paths_))
     return false;
 
-  metadata_.reset(new FileCacheMetadata(blocking_task_runner_));
+  metadata_.reset(new FileCacheMetadata(blocking_task_runner_.get()));
 
   switch (metadata_->Initialize(cache_paths_[CACHE_TYPE_META])) {
     case FileCacheMetadata::INITIALIZE_FAILED:
       return false;
 
     case FileCacheMetadata::INITIALIZE_OPENED:  // Do nothing.
       break;
 
     case FileCacheMetadata::INITIALIZE_CREATED: {
       CacheMap cache_map;
@@ skipping 245 matching lines @@
 }
 
 // static
 FileCache::CacheSubDirectoryType FileCache::GetSubDirectoryType(
     const FileCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 }  // namespace internal
 }  // namespace drive