Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 370 matching lines @@
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
 // GDataFileSystem::AddUploadedFileParams implementation.
 struct GDataFileSystem::AddUploadedFileParams {
   AddUploadedFileParams(UploadMode upload_mode,
                         DriveDirectory* parent_dir,
                         scoped_ptr<DriveEntry> new_entry,
                         const FilePath& file_content_path,
-                        GDataCache::FileOperationType cache_operation,
+                        DriveCache::FileOperationType cache_operation,
                         const base::Closure& callback)
   : upload_mode(upload_mode),
     parent_dir(parent_dir),
     new_entry(new_entry.Pass()),
     file_content_path(file_content_path),
     cache_operation(cache_operation),
     callback(callback) {
   }
 
   UploadMode upload_mode;
   DriveDirectory* parent_dir;
   scoped_ptr<DriveEntry> new_entry;
   FilePath file_content_path;
-  GDataCache::FileOperationType cache_operation;
+  DriveCache::FileOperationType cache_operation;
   base::Closure callback;
   std::string resource_id;
   std::string md5;
 };
 
 
 // GDataFileSystem class implementation.
 
 GDataFileSystem::GDataFileSystem(
     Profile* profile,
-    GDataCache* cache,
+    DriveCache* cache,
     DriveServiceInterface* drive_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
       drive_service_(drive_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
@@ skipping 367 matching lines @@
     GDataFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
 
   if (error == GDATA_FILE_OK && upload_file_info->entry.get()) {
     AddUploadedFile(UPLOAD_NEW_FILE,
                     upload_file_info->gdata_path.DirName(),
                     upload_file_info->entry.Pass(),
                     upload_file_info->file_path,
-                    GDataCache::FILE_OPERATION_COPY,
+                    DriveCache::FILE_OPERATION_COPY,
                     base::Bind(&OnAddUploadFileCompleted, callback, error));
   } else if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::Copy(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
@@ skipping 693 matching lines @@
     GDataFileError* error =
         new GDataFileError(GDATA_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     DriveFileType* file_type = new DriveFileType(REGULAR_FILE);
     util::PostBlockingPoolSequencedTaskAndReply(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
                    cache_->GetCacheDirectoryPath(
-                       GDataCache::CACHE_TYPE_TMP_DOCUMENTS),
+                       DriveCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(entry_proto->file_specific_info().alternate_url()),
                    entry_proto->resource_id(),
                    error,
                    temp_file_path,
                    mime_type,
                    file_type),
         base::Bind(&RunGetFileCallbackHelper,
                    get_file_callback,
                    base::Owned(error),
                    base::Owned(temp_file_path),
                    base::Owned(mime_type),
                    base::Owned(file_type)));
     return;
   }
 
   // Returns absolute path of the file if it were cached or to be cached.
   FilePath local_tmp_path = cache_->GetCacheFilePath(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
-      GDataCache::CACHE_TYPE_TMP,
-      GDataCache::CACHED_FILE_FROM_SERVER);
+      DriveCache::CACHE_TYPE_TMP,
+      DriveCache::CACHED_FILE_FROM_SERVER);
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(
           &GDataFileSystem::OnGetFileFromCache,
           ui_weak_ptr_,
           GetFileFromCacheParams(
               file_path,
               local_tmp_path,
               GURL(entry_proto->content_url()),
@@ skipping 140 matching lines @@
 
   DCHECK_EQ(params.resource_id, fresh_entry->resource_id());
   scoped_ptr<DriveFile> fresh_entry_as_file(
       fresh_entry.release()->AsDriveFile());
   resource_metadata_->RefreshFile(fresh_entry_as_file.Pass());
 
   bool* has_enough_space = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
-      base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
+      base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
       base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
                  ui_weak_ptr_,
                  params,
                  content_url,
                  cache_file_path,
                  base::Owned(has_enough_space)));
 }
@@ skipping 388 matching lines @@
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   AddUploadedFile(UPLOAD_EXISTING_FILE,
                   upload_file_info->gdata_path.DirName(),
                   upload_file_info->entry.Pass(),
                   upload_file_info->file_path,
-                  GDataCache::FILE_OPERATION_MOVE,
+                  DriveCache::FILE_OPERATION_MOVE,
                   base::Bind(&OnAddUploadFileCompleted, callback, error));
 }
 
 void GDataFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::GetAvailableSpaceOnUIThread,
                                ui_weak_ptr_,
                                CreateRelayCallback(callback)));
@@ skipping 360 matching lines @@
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
-      base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
+      base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  has_enough_space),
       base::Bind(&GDataFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
@@ skipping 23 matching lines @@
 
   // Make sure that downloaded file is properly stored in cache. We don't have
   // to wait for this operation to finish since the user can already use the
   // downloaded file.
   if (error == GDATA_FILE_OK) {
     if (*has_enough_space) {
       cache_->StoreOnUIThread(
           params.resource_id,
           params.md5,
           downloaded_file_path,
-          GDataCache::FILE_OPERATION_MOVE,
+          DriveCache::FILE_OPERATION_MOVE,
           base::Bind(&GDataFileSystem::OnDownloadStoredToCache,
                      ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
       util::PostBlockingPoolSequencedTask(
           FROM_HERE,
           blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
@@ skipping 277 matching lines @@
       base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
   return GDATA_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
-    GDataCache::FileOperationType cache_operation,
+    DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // AddUploadedFile() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::AddUploadedFileOnUIThread,
                  ui_weak_ptr_,
                  upload_mode,
                  virtual_dir_path,
                  base::Passed(&entry),
                  file_content_path,
                  cache_operation,
                  callback));
 }
 
 void GDataFileSystem::AddUploadedFileOnUIThread(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
-    GDataCache::FileOperationType cache_operation,
+    DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // ScopedClosureRunner ensures that the specified callback is always invoked
   // upon return or passed on.
   base::ScopedClosureRunner callback_runner(callback);
 
   if (!entry.get()) {
     NOTREACHED();
     return;
@@ skipping 124 matching lines @@
   if (!new_entry.get()) {
     return;
   }
 
   resource_metadata_->RefreshFile(new_entry.Pass());
 
   // Add the file to the cache if we have uploaded a new file.
   cache_->StoreOnUIThread(resource_id,
                           md5,
                           file_content_path,
-                          GDataCache::FILE_OPERATION_MOVE,
+                          DriveCache::FILE_OPERATION_MOVE,
                           base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                      callback));
 }
 
 
 void GDataFileSystem::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 356 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata