Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_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/gdata/gdata_cache.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_cache_metadata.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace gdata {
@@ skipping 161 matching lines @@
       DVLOG(1) << "Deleted " << current.value();
   }
 }
 
 // Appends |resource_id| ID to |to_fetch| if the file is pinned but not
 // fetched (not present locally), or to |to_upload| if the file is dirty
 // but not uploaded.
 void CollectBacklog(std::vector<std::string>* to_fetch,
                     std::vector<std::string>* to_upload,
                     const std::string& resource_id,
-                    const GDataCacheEntry& cache_entry) {
+                    const DriveCacheEntry& cache_entry) {
   DCHECK(to_fetch);
   DCHECK(to_upload);
 
   if (cache_entry.is_pinned() && !cache_entry.is_present())
     to_fetch->push_back(resource_id);
 
   if (cache_entry.is_dirty())
     to_upload->push_back(resource_id);
 }
 
 // Appends |resource_id| ID to |resource_ids| if the file is pinned and
 // present (cached locally).
 void CollectExistingPinnedFile(std::vector<std::string>* resource_ids,
                                const std::string& resource_id,
-                               const GDataCacheEntry& cache_entry) {
+                               const DriveCacheEntry& cache_entry) {
   DCHECK(resource_ids);
 
   if (cache_entry.is_pinned() && cache_entry.is_present())
     resource_ids->push_back(resource_id);
 }
 
 // Appends |resource_id| ID to |resource_ids| unconditionally.
 void CollectAnyFile(std::vector<std::string>* resource_ids,
                     const std::string& resource_id,
-                    const GDataCacheEntry& /* cache_entry */) {
+                    const DriveCacheEntry& /* cache_entry */) {
   DCHECK(resource_ids);
 
   resource_ids->push_back(resource_id);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement SetMountedStateOnUIThread and ClearAllOnUIThread.
 void RunChangeCacheStateCallback(const ChangeCacheStateCallback& callback,
                                  const GDataFileError* error,
                                  const FilePath* cache_file_path) {
@@ skipping 57 matching lines @@
 
   if (!callback.is_null())
     callback.Run(*resource_ids);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement GetCacheEntryOnUIThread().
 void RunGetCacheEntryCallback(
     const GetCacheEntryCallback& callback,
     bool* success,
-    GDataCacheEntry* cache_entry) {
+    DriveCacheEntry* cache_entry) {
   DCHECK(success);
   DCHECK(cache_entry);
 
   if (!callback.is_null())
     callback.Run(*success, *cache_entry);
 }
 
 }  // namespace
 
 GDataCache::GDataCache(const FilePath& cache_root_path,
@@ skipping 63 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void GDataCache::GetCacheEntryOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool* success = new bool(false);
-  GDataCacheEntry* cache_entry = new GDataCacheEntry;
+  DriveCacheEntry* cache_entry = new DriveCacheEntry;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataCache::GetCacheEntryHelper,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  success,
                  cache_entry),
       base::Bind(&RunGetCacheEntryCallback,
                  callback,
@@ skipping 310 matching lines @@
 void GDataCache::ForceRescanOnUIThreadForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GDataCache::ForceRescanForTesting, base::Unretained(this)));
 }
 
 bool GDataCache::GetCacheEntry(const std::string& resource_id,
                                const std::string& md5,
-                               GDataCacheEntry* entry) {
+                               DriveCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
   return metadata_->GetCacheEntry(resource_id, md5, entry);
 }
 
 // static
 GDataCache* GDataCache::CreateGDataCacheOnUIThread(
     const FilePath& cache_root_path,
     base::SequencedTaskRunner* blocking_task_runner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 68 matching lines @@
 }
 
 void GDataCache::GetFile(const std::string& resource_id,
                          const std::string& md5,
                          GDataFileError* error,
                          FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (GetCacheEntry(resource_id, md5, &cache_entry) &&
       cache_entry.is_present()) {
     CachedFileOrigin file_origin;
     if (cache_entry.is_mounted()) {
       file_origin = CACHED_FILE_MOUNTED;
     } else if (cache_entry.is_dirty()) {
       file_origin = CACHED_FILE_LOCALLY_MODIFIED;
     } else {
       file_origin = CACHED_FILE_FROM_SERVER;
     }
@@ skipping 31 matching lines @@
       return;
     }
   }
 
   FilePath dest_path;
   FilePath symlink_path;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   // If file was previously pinned, store it in persistent dir and create
   // symlink in pinned dir.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (GetCacheEntry(resource_id, md5, &cache_entry)) {  // File exists in cache.
     // If file is dirty or mounted, return error.
     if (cache_entry.is_dirty() || cache_entry.is_mounted()) {
       LOG(WARNING) << "Can't store a file to replace a "
                    << (cache_entry.is_dirty() ? "dirty" : "mounted")
                    << " file: res_id=" << resource_id
                    << ", md5=" << md5;
       *error = GDATA_FILE_ERROR_IN_USE;
       return;
     }
@@ skipping 59 matching lines @@
                      GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath source_path;
   FilePath dest_path;
   FilePath symlink_path;
   bool create_symlink = true;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_PERSISTENT;
 
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     // Entry does not exist in cache.
     // Set both |dest_path| and |source_path| to /dev/null, so that:
     // 1) ModifyCacheState won't move files when |source_path| and |dest_path|
     //    are the same.
     // 2) symlinks to /dev/null will be picked up by GDataSyncClient to download
     //    pinned files that don't exist in cache.
     dest_path = FilePath::FromUTF8Unsafe(util::kSymLinkToDevNull);
     source_path = dest_path;
 
@@ skipping 61 matching lines @@
 }
 
 void GDataCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
                        GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // Unpinning a file means its entry must exist in cache.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     LOG(WARNING) << "Can't unpin a file that wasn't pinned or cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = GDATA_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // Entry exists in cache, determines source and destination paths.
 
@@ skipping 73 matching lines @@
 
   // Parse file path to obtain resource_id, md5 and extra_extension.
   std::string resource_id;
   std::string md5;
   std::string extra_extension;
   util::ParseCacheFilePath(file_path, &resource_id, &md5, &extra_extension);
   // The extra_extension shall be ".mounted" iff we're unmounting.
   DCHECK(!to_mount == (extra_extension == util::kMountedArchiveFileExtension));
 
   // Get cache entry associated with the resource_id and md5
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     *error = GDATA_FILE_ERROR_NOT_FOUND;
     return;
   }
   if (to_mount == cache_entry.is_mounted()) {
     *error = GDATA_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Get the subdir type and path for the unmounted state.
@@ skipping 42 matching lines @@
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // 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.
   // So, search for entry in cache without comparing md5.
 
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't mark dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = GDATA_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // If a file is already dirty (i.e. MarkDirtyInCache was called before),
@@ skipping 82 matching lines @@
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // 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.
   // So, search for entry in cache without comparing md5.
 
   // Committing a file dirty means its entry and actual file blob must exist in
   // cache.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't commit dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     *error = GDATA_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // If a file is not dirty (it should have been marked dirty via
@@ skipping 33 matching lines @@
 
 void GDataCache::ClearDirty(const std::string& resource_id,
                             const std::string& md5,
                             FileOperationType file_operation_type,
                             GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
   if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't clear dirty state of a file that wasn't cached: "
                  << "res_id=" << resource_id
                  << ", md5=" << md5;
     *error = GDATA_FILE_ERROR_NOT_FOUND;
     return;
@@ skipping 67 matching lines @@
 }
 
 void GDataCache::Remove(const std::string& resource_id,
                         GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // 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.
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
 
   // If entry doesn't exist or is dirty or mounted in cache, nothing to do.
   const bool entry_found =
       GetCacheEntry(resource_id, std::string(), &cache_entry);
   if (!entry_found || cache_entry.is_dirty() || cache_entry.is_mounted()) {
     DVLOG(1) << "Entry is "
              << (entry_found ?
                  (cache_entry.is_dirty() ? "dirty" : "mounted") :
                  "non-existent")
              << " in cache, not removing";
@@ skipping 99 matching lines @@
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == GDATA_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCacheCommitted(resource_id));
 }
 
 void GDataCache::GetCacheEntryHelper(const std::string& resource_id,
                                      const std::string& md5,
                                      bool* success,
-                                     GDataCacheEntry* cache_entry) {
+                                     DriveCacheEntry* cache_entry) {
   AssertOnSequencedWorkerPool();
   DCHECK(success);
   DCHECK(cache_entry);
 
   *success = GetCacheEntry(resource_id, md5, cache_entry);
 }
 
 // static
 FilePath GDataCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
@@ skipping 33 matching lines @@
       PLOG(ERROR) << "Error creating directory " << paths_to_create[i].value();
     } else {
       DVLOG(1) << "Created directory " << paths_to_create[i].value();
     }
   }
   return success;
 }
 
 // static
 GDataCache::CacheSubDirectoryType GDataCache::GetSubDirectoryType(
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata