drive: Rename FileCache methods in a blocking pool centric manner

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/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 462 matching lines @@
   // TODO(hashimoto): Support pinning directories. crbug.com/127831
   if (entry && entry->file_info().is_directory())
     error = FILE_ERROR_NOT_A_FILE;
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
   DCHECK(entry);
 
-  cache_->Pin(entry->resource_id(), entry->file_specific_info().file_md5(),
-              callback);
+  cache_->PinOnUIThread(entry->resource_id(),
+                        entry->file_specific_info().file_md5(), callback);
 }
 
 void FileSystem::Unpin(const base::FilePath& file_path,
                        const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GetEntryInfoByPath(file_path,
                      base::Bind(&FileSystem::UnpinAfterGetEntryInfoByPath,
                                 weak_ptr_factory_.GetWeakPtr(),
@@ skipping 10 matching lines @@
   // TODO(hashimoto): Support pinning directories. crbug.com/127831
   if (entry && entry->file_info().is_directory())
     error = FILE_ERROR_NOT_A_FILE;
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
   DCHECK(entry);
 
-  cache_->Unpin(entry->resource_id(), entry->file_specific_info().file_md5(),
-                callback);
+  cache_->UnpinOnUIThread(entry->resource_id(),
+                          entry->file_specific_info().file_md5(), callback);
 }
 
 void FileSystem::GetFileByPath(const base::FilePath& file_path,
                                const GetFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryInfoByPathOnUIThread(
       file_path,
       base::Bind(&FileSystem::OnGetEntryInfoCompleteForGetFileByPath,
@@ skipping 326 matching lines @@
         base::Bind(
             &FileSystem::GetResolvedFileByPathAfterCreateDocumentJsonFile,
             weak_ptr_factory_.GetWeakPtr(),
             base::Passed(&params),
             base::Owned(temp_file_path)));
     return;
   }
 
   // Returns absolute path of the file if it were cached or to be cached.
   ResourceEntry* entry_ptr = params->entry.get();
-  cache_->GetFile(
+  cache_->GetFileOnUIThread(
       entry_ptr->resource_id(),
       entry_ptr->file_specific_info().file_md5(),
       base::Bind(
           &FileSystem::GetResolvedFileByPathAfterGetFileFromCache,
           weak_ptr_factory_.GetWeakPtr(),
           base::Passed(&params)));
 }
 
 void FileSystem::GetResolvedFileByPathAfterCreateDocumentJsonFile(
     scoped_ptr<GetResolvedFileParams> params,
@@ skipping 89 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
 
   if (error != FILE_ERROR_OK) {
     params->OnError(error);
     return;
   }
 
   int64 file_size = entry->file_info().size();
   params->entry = entry.Pass();  // Update the entry in |params|.
-  cache_->FreeDiskSpaceIfNeededFor(
+  cache_->FreeDiskSpaceIfNeededForOnUIThread(
       file_size,
       base::Bind(&FileSystem::GetResolvedFileByPathAfterFreeDiskSpace,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  download_url));
 }
 
 void FileSystem::GetResolvedFileByPathAfterFreeDiskSpace(
     scoped_ptr<GetResolvedFileParams> params,
     const GURL& download_url,
@@ skipping 56 matching lines @@
 void FileSystem::GetResolvedFileByPathAfterDownloadFile(
     scoped_ptr<GetResolvedFileParams> params,
     google_apis::GDataErrorCode status,
     const base::FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
 
   // If user cancels download of a pinned-but-not-fetched file, mark file as
   // unpinned so that we do not sync the file again.
   if (status == google_apis::GDATA_CANCELLED) {
-    cache_->GetCacheEntry(
+    cache_->GetCacheEntryOnUIThread(
         params->entry->resource_id(),
         params->entry->file_specific_info().file_md5(),
         base::Bind(
             &FileSystem::GetResolvedFileByPathAfterGetCacheEntryForCancel,
             weak_ptr_factory_.GetWeakPtr(),
             params->entry->resource_id(),
             params->entry->file_specific_info().file_md5()));
   }
 
   FileError error = util::GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     params->OnError(error);
     return;
   }
 
   ResourceEntry* entry = params->entry.get();
-  cache_->Store(entry->resource_id(),
-                entry->file_specific_info().file_md5(),
-                downloaded_file_path,
-                internal::FileCache::FILE_OPERATION_MOVE,
-                base::Bind(&FileSystem::GetResolvedFileByPathAfterStore,
-                           weak_ptr_factory_.GetWeakPtr(),
-                           base::Passed(&params),
-                           downloaded_file_path));
+  cache_->StoreOnUIThread(
+      entry->resource_id(),
+      entry->file_specific_info().file_md5(),
+      downloaded_file_path,
+      internal::FileCache::FILE_OPERATION_MOVE,
+      base::Bind(&FileSystem::GetResolvedFileByPathAfterStore,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&params),
+                 downloaded_file_path));
 }
 
 void FileSystem::GetResolvedFileByPathAfterGetCacheEntryForCancel(
     const std::string& resource_id,
     const std::string& md5,
     bool success,
     const FileCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(hshi): http://crbug.com/127138 notify when file properties change.
   // This allows file manager to clear the "Available offline" checkbox.
   if (success && cache_entry.is_pinned()) {
-    cache_->Unpin(resource_id,
-                  md5,
-                  base::Bind(&util::EmptyFileOperationCallback));
+    cache_->UnpinOnUIThread(resource_id,
+                            md5,
+                            base::Bind(&util::EmptyFileOperationCallback));
   }
 }
 
 void FileSystem::GetResolvedFileByPathAfterStore(
     scoped_ptr<GetResolvedFileParams> params,
     const base::FilePath& downloaded_file_path,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
 
   if (error != FILE_ERROR_OK) {
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&file_util::Delete),
                    downloaded_file_path,
                    false /* recursive*/));
     params->OnError(error);
     return;
   }
   // Storing to cache changes the "offline available" status, hence notify.
   OnDirectoryChanged(params->drive_file_path.DirName());
 
   ResourceEntry* entry = params->entry.get();
-  cache_->GetFile(
+  cache_->GetFileOnUIThread(
       entry->resource_id(),
       entry->file_specific_info().file_md5(),
       base::Bind(&FileSystem::GetResolvedFileByPathAfterGetFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params)));
 }
 
 void FileSystem::GetResolvedFileByPathAfterGetFile(
     scoped_ptr<GetResolvedFileParams> params,
     FileError error,
@@ skipping 262 matching lines @@
   if (error != FILE_ERROR_OK && error != FILE_ERROR_EXISTS) {
     params.callback.Run(error);
     return;
   }
 
   OnDirectoryChanged(file_path.DirName());
 
   // At this point, upload to the server is fully succeeded. Failure to store to
   // cache is not a fatal error, so we wrap the callback with IgnoreError, and
   // always return success to the caller.
-  cache_->Store(params.resource_id,
-                params.md5,
-                params.file_content_path,
-                internal::FileCache::FILE_OPERATION_COPY,
-                base::Bind(&IgnoreError, params.callback));
+  cache_->StoreOnUIThread(params.resource_id,
+                          params.md5,
+                          params.file_content_path,
+                          internal::FileCache::FILE_OPERATION_COPY,
+                          base::Bind(&IgnoreError, params.callback));
 }
 
 void FileSystem::GetMetadata(
     const GetFilesystemMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileSystemMetadata metadata;
   metadata.refreshing = change_list_loader_->IsRefreshing();
 
@@ skipping 23 matching lines @@
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error, base::FilePath());
     return;
   }
 
   DCHECK(entry);
-  cache_->MarkAsMounted(entry->resource_id(),
-                        entry->file_specific_info().file_md5(),
-                        callback);
+  cache_->MarkAsMountedOnUIThread(entry->resource_id(),
+                                  entry->file_specific_info().file_md5(),
+                                  callback);
 }
 
 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;
   }
-  cache_->MarkAsUnmounted(cache_file_path, callback);
+  cache_->MarkAsUnmountedOnUIThread(cache_file_path, callback);
 }
 
 void FileSystem::GetCacheEntryByResourceId(
     const std::string& resource_id,
     const std::string& md5,
     const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!resource_id.empty());
   DCHECK(!callback.is_null());
 
-  cache_->GetCacheEntry(resource_id, md5, callback);
+  cache_->GetCacheEntryOnUIThread(resource_id, md5, callback);
 }
 
 void FileSystem::OnDisableDriveHostedFilesChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrefService* pref_service = profile_->GetPrefs();
   SetHideHostedDocuments(
       pref_service->GetBoolean(prefs::kDisableDriveHostedFiles));
 }
 
 void FileSystem::SetHideHostedDocuments(bool hide) {
@@ skipping 103 matching lines @@
   DCHECK(!params.callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     params.callback.Run(error, base::FilePath());
     return;
   }
 
   // OpenFile ensures that the file is a regular file.
   DCHECK(entry && !entry->file_specific_info().is_hosted_document());
 
-  cache_->MarkDirty(
+  cache_->MarkDirtyOnUIThread(
       params.resource_id,
       params.md5,
       base::Bind(&FileSystem::OnMarkDirtyInCacheCompleteForOpenFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  params));
 }
 
 void FileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
     const GetFileCompleteForOpenParams& params,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     params.callback.Run(error, base::FilePath());
     return;
   }
 
-  cache_->GetFile(params.resource_id, params.md5, params.callback);
+  cache_->GetFileOnUIThread(params.resource_id, params.md5, params.callback);
 }
 
 void FileSystem::OnOpenFileFinished(
     const base::FilePath& file_path,
     const OpenFileCallback& callback,
     FileError result,
     const base::FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 46 matching lines @@
     callback.Run(error);
     return;
   }
 
   // Step 2 of CloseFile: Commit the modification in cache. This will trigger
   // background upload.
   // TODO(benchan,kinaba): Call ClearDirtyInCache instead of CommitDirtyInCache
   // if the file has not been modified. Come up with a way to detect the
   // intactness effectively, or provide a method for user to declare it when
   // calling CloseFile().
-  cache_->CommitDirty(entry->resource_id(),
-                      entry->file_specific_info().file_md5(),
-                      callback);
+  cache_->CommitDirtyOnUIThread(entry->resource_id(),
+                                entry->file_specific_info().file_md5(),
+                                callback);
 }
 
 void FileSystem::CloseFileFinalize(const base::FilePath& file_path,
                                    const FileOperationCallback& callback,
                                    FileError result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Step 3 of CloseFile.
   // All the invocation of |callback| from operations initiated from CloseFile
@@ skipping 15 matching lines @@
   // For entries that will never be cached, use the original entry info as is.
   if (!entry->has_file_specific_info() ||
       entry->file_specific_info().is_hosted_document()) {
     callback.Run(FILE_ERROR_OK, entry.Pass());
     return;
   }
 
   // Checks if the file is cached and modified locally.
   const std::string resource_id = entry->resource_id();
   const std::string md5 = entry->file_specific_info().file_md5();
-  cache_->GetCacheEntry(
+  cache_->GetCacheEntryOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &FileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
           weak_ptr_factory_.GetWeakPtr(),
           base::Passed(&entry),
           callback));
 }
 
 void FileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
     scoped_ptr<ResourceEntry> entry,
     const GetEntryInfoCallback& callback,
     bool success,
     const FileCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (!success || !cache_entry.is_dirty()) {
     callback.Run(FILE_ERROR_OK, entry.Pass());
     return;
   }
 
   // Gets the cache file path.
   const std::string& resource_id = entry->resource_id();
   const std::string& md5 = entry->file_specific_info().file_md5();
-  cache_->GetFile(
+  cache_->GetFileOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &FileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
           weak_ptr_factory_.GetWeakPtr(),
           base::Passed(&entry),
           callback));
 }
 
 void FileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
@@ skipping 42 matching lines @@
   util::ConvertPlatformFileInfoToResourceEntry(*file_info, &entry_file_info);
   *entry->mutable_file_info() = entry_file_info;
   callback.Run(FILE_ERROR_OK, entry.Pass());
 }
 
 void FileSystem::CancelJobInScheduler(JobID id) {
   scheduler_->CancelJob(id);
 }
 
 }  // namespace drive