Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/gdata_util.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_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 49 matching lines @@
                                      base::PLATFORM_FILE_READ |
                                      base::PLATFORM_FILE_EXCLUSIVE_READ |
                                      base::PLATFORM_FILE_ASYNC;
 
 GDataFileSystemInterface* GetGDataFileSystem(Profile* profile) {
   GDataSystemService* system_service =
       GDataSystemServiceFactory::GetForProfile(profile);
   return system_service ? system_service->file_system() : NULL;
 }
 
-GDataCache* GetGDataCache(Profile* profile) {
+DriveCache* GetDriveCache(Profile* profile) {
   GDataSystemService* system_service =
       GDataSystemServiceFactory::GetForProfile(profile);
   return system_service ? system_service->cache() : NULL;
 }
 
 FileWriteHelper* GetFileWriteHelper(Profile* profile) {
   GDataSystemService* system_service =
       GDataSystemServiceFactory::GetForProfile(profile);
   return system_service ? system_service->file_write_helper() : NULL;
 }
 
-void GetHostedDocumentURLBlockingThread(const FilePath& gdata_cache_path,
+void GetHostedDocumentURLBlockingThread(const FilePath& drive_cache_path,
                                         GURL* url) {
   std::string json;
-  if (!file_util::ReadFileToString(gdata_cache_path, &json)) {
-    NOTREACHED() << "Unable to read file " << gdata_cache_path.value();
+  if (!file_util::ReadFileToString(drive_cache_path, &json)) {
+    NOTREACHED() << "Unable to read file " << drive_cache_path.value();
     return;
   }
   DVLOG(1) << "Hosted doc content " << json;
   scoped_ptr<base::Value> val(base::JSONReader::Read(json));
   base::DictionaryValue* dict_val;
   if (!val.get() || !val->GetAsDictionary(&dict_val)) {
     NOTREACHED() << "Parse failure for " << json;
     return;
   }
   std::string edit_url;
@@ skipping 26 matching lines @@
     return;
 
   DCHECK(entry_proto.get());
   const std::string& base_name = entry_proto->base_name();
   const GURL edit_url = GetFileResourceUrl(resource_id, base_name);
   OpenEditURLUIThread(profile, &edit_url);
   DVLOG(1) << "OnFindEntryByResourceId " << edit_url;
 }
 
 // Invoked upon completion of GetEntryInfoByPath initiated by
-// InsertGDataCachePathPermissions.
-void OnGetEntryInfoForInsertGDataCachePathsPermissions(
+// InsertDriveCachePathPermissions.
+void OnGetEntryInfoForInsertDriveCachePathsPermissions(
     Profile* profile,
     std::vector<std::pair<FilePath, int> >* cache_paths,
     const base::Closure& callback,
     GDataFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(profile);
   DCHECK(cache_paths);
   DCHECK(!callback.is_null());
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
-  GDataCache* cache = GetGDataCache(profile);
+  DriveCache* cache = GetDriveCache(profile);
   if (!cache || error != GDATA_FILE_OK) {
     callback.Run();
     return;
   }
 
   DCHECK(entry_proto.get());
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& file_md5 = entry_proto->file_specific_info().file_md5();
 
   // We check permissions for raw cache file paths only for read-only
   // operations (when fileEntry.file() is called), so read only permissions
   // should be sufficient for all cache paths. For the rest of supported
   // operations the file access check is done for drive/ paths.
   cache_paths->push_back(std::make_pair(
       cache->GetCacheFilePath(resource_id, file_md5,
-          GDataCache::CACHE_TYPE_PERSISTENT,
-          GDataCache::CACHED_FILE_FROM_SERVER),
+          DriveCache::CACHE_TYPE_PERSISTENT,
+          DriveCache::CACHED_FILE_FROM_SERVER),
       kReadOnlyFilePermissions));
   // TODO(tbarzic): When we start supporting openFile operation, we may have to
   // change permission for localy modified files to match handler's permissions.
   cache_paths->push_back(std::make_pair(
       cache->GetCacheFilePath(resource_id, file_md5,
-          GDataCache::CACHE_TYPE_PERSISTENT,
-          GDataCache::CACHED_FILE_LOCALLY_MODIFIED),
+          DriveCache::CACHE_TYPE_PERSISTENT,
+          DriveCache::CACHED_FILE_LOCALLY_MODIFIED),
      kReadOnlyFilePermissions));
   cache_paths->push_back(std::make_pair(
       cache->GetCacheFilePath(resource_id, file_md5,
-          GDataCache::CACHE_TYPE_PERSISTENT,
-          GDataCache::CACHED_FILE_MOUNTED),
+          DriveCache::CACHE_TYPE_PERSISTENT,
+          DriveCache::CACHED_FILE_MOUNTED),
      kReadOnlyFilePermissions));
   cache_paths->push_back(std::make_pair(
       cache->GetCacheFilePath(resource_id, file_md5,
-          GDataCache::CACHE_TYPE_TMP,
-          GDataCache::CACHED_FILE_FROM_SERVER),
+          DriveCache::CACHE_TYPE_TMP,
+          DriveCache::CACHED_FILE_FROM_SERVER),
       kReadOnlyFilePermissions));
 
   callback.Run();
 }
 
 bool ParseTimezone(const base::StringPiece& timezone,
                    bool ahead,
                    int* out_offset_to_utc_in_minutes) {
   DCHECK(out_offset_to_utc_in_minutes);
 
@@ skipping 35 matching lines @@
 GURL GetFileResourceUrl(const std::string& resource_id,
                         const std::string& file_name) {
   std::string url(base::StringPrintf(
       "%s:%s",
       chrome::kDriveScheme,
       net::EscapePath(resource_id).c_str()));
   return GURL(url);
 }
 
 void ModifyGDataFileResourceUrl(Profile* profile,
-                                const FilePath& gdata_cache_path,
+                                const FilePath& drive_cache_path,
                                 GURL* url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileSystemInterface* file_system = GetGDataFileSystem(profile);
   if (!file_system)
     return;
-  GDataCache* cache = GetGDataCache(profile);
+  DriveCache* cache = GetDriveCache(profile);
   if (!cache)
     return;
 
-  if (cache->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP_DOCUMENTS).
-          IsParent(gdata_cache_path)) {
+  if (cache->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP_DOCUMENTS).
+      IsParent(drive_cache_path)) {
     // Handle hosted documents. The edit url is in the temporary file, so we
     // read it on a blocking thread.
     GURL* edit_url = new GURL();
     content::BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
         base::Bind(&GetHostedDocumentURLBlockingThread,
-                   gdata_cache_path, edit_url),
+                   drive_cache_path, edit_url),
         base::Bind(&OpenEditURLUIThread, profile, base::Owned(edit_url)));
     *url = GURL();
-  } else if (cache->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP).
-                 IsParent(gdata_cache_path) ||
-             cache->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PERSISTENT).
-                 IsParent(gdata_cache_path)) {
+  } else if (cache->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP).
+                 IsParent(drive_cache_path) ||
+             cache->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_PERSISTENT).
+                 IsParent(drive_cache_path)) {
     // Handle all other gdata files.
     const std::string resource_id =
-        gdata_cache_path.BaseName().RemoveExtension().AsUTF8Unsafe();
+        drive_cache_path.BaseName().RemoveExtension().AsUTF8Unsafe();
     file_system->GetEntryInfoByResourceId(
         resource_id,
         base::Bind(&OnGetEntryInfoByResourceId,
                    profile,
                    resource_id));
     *url = GURL();
   }
 }
 
 bool IsUnderGDataMountPoint(const FilePath& path) {
@@ skipping 10 matching lines @@
 
   // -1 to include 'drive'.
   FilePath extracted;
   for (size_t i = arraysize(kGDataMountPointPathComponents) - 1;
        i < components.size(); ++i) {
     extracted = extracted.Append(components[i]);
   }
   return extracted;
 }
 
-void InsertGDataCachePathsPermissions(
+void InsertDriveCachePathsPermissions(
     Profile* profile,
     scoped_ptr<std::vector<FilePath> > gdata_paths,
     std::vector<std::pair<FilePath, int> >* cache_paths,
     const base::Closure& callback) {
   DCHECK(profile);
   DCHECK(gdata_paths.get());
   DCHECK(cache_paths);
   DCHECK(!callback.is_null());
 
   GDataFileSystemInterface* file_system = GetGDataFileSystem(profile);
   if (!file_system || gdata_paths->empty()) {
     callback.Run();
     return;
   }
 
   // Remove one file path entry from the back of the input vector |gdata_paths|.
   FilePath gdata_path = gdata_paths->back();
   gdata_paths->pop_back();
 
   // Call GetEntryInfoByPath() to get file info for |gdata_path| then insert
   // all possible cache paths to the output vector |cache_paths|.
   // Note that we can only process one file path at a time. Upon completion
-  // of OnGetEntryInfoForInsertGDataCachePathsPermissions(), we recursively call
-  // InsertGDataCachePathsPermissions() to process the next file path from the
+  // of OnGetEntryInfoForInsertDriveCachePathsPermissions(), we recursively call
+  // InsertDriveCachePathsPermissions() to process the next file path from the
   // back of the input vector |gdata_paths| until it is empty.
   file_system->GetEntryInfoByPath(
       gdata_path,
-      base::Bind(&OnGetEntryInfoForInsertGDataCachePathsPermissions,
+      base::Bind(&OnGetEntryInfoForInsertDriveCachePathsPermissions,
                  profile,
                  cache_paths,
-                 base::Bind(&InsertGDataCachePathsPermissions,
+                 base::Bind(&InsertDriveCachePathsPermissions,
                              profile,
                              base::Passed(&gdata_paths),
                              cache_paths,
                              callback)));
 }
 
 bool IsGDataAvailable(Profile* profile) {
   if (!chromeos::UserManager::Get()->IsUserLoggedIn() ||
       chromeos::UserManager::Get()->IsLoggedInAsGuest() ||
       chromeos::UserManager::Get()->IsLoggedInAsDemoUser())
@@ skipping 315 matching lines @@
     const base::Closure& reply_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool posted = blocking_task_runner->PostTaskAndReply(
       from_here, request_task, reply_task);
   DCHECK(posted);
 }
 
 }  // namespace util
 }  // namespace gdata