Rename GData to Drive in drive_file_system_util

chrome/browser/chromeos/gdata/drive_file_system_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/drive_file_system_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 19 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace util {
 
 namespace {
 
-const char kGDataSpecialRootPath[] = "/special";
+const char kDriveSpecialRootPath[] = "/special";
 
-const char kGDataMountPointPath[] = "/special/drive";
+const char kDriveMountPointPath[] = "/special/drive";
 
-const FilePath::CharType* kGDataMountPointPathComponents[] = {
+const FilePath::CharType* kDriveMountPointPathComponents[] = {
   "/", "special", "drive"
 };
 
 const int kReadOnlyFilePermissions = base::PLATFORM_FILE_OPEN |
                                      base::PLATFORM_FILE_READ |
                                      base::PLATFORM_FILE_EXCLUSIVE_READ |
                                      base::PLATFORM_FILE_ASYNC;
 
 DriveFileSystemInterface* GetDriveFileSystem(Profile* profile) {
   DriveSystemService* system_service =
@@ skipping 38 matching lines @@
 
 void OpenEditURLUIThread(Profile* profile, const GURL* edit_url) {
   Browser* browser = browser::FindLastActiveWithProfile(profile);
   if (browser) {
     browser->OpenURL(content::OpenURLParams(*edit_url, content::Referrer(),
         CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   }
 }
 
 // Invoked upon completion of GetEntryInfoByResourceId initiated by
-// ModifyGDataFileResourceUrl.
+// ModifyDriveFileResourceUrl.
 void OnGetEntryInfoByResourceId(Profile* profile,
                                 const std::string& resource_id,
                                 DriveFileError error,
                                 const FilePath& /* gdata_file_path */,
                                 scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK)
     return;
 
@@ skipping 54 matching lines @@
       cache->GetCacheFilePath(resource_id, file_md5,
           DriveCache::CACHE_TYPE_TMP,
           DriveCache::CACHED_FILE_FROM_SERVER),
       kReadOnlyFilePermissions));
 
   callback.Run();
 }
 
 }  // namespace
 
-const FilePath& GetGDataMountPointPath() {
+const FilePath& GetDriveMountPointPath() {
   CR_DEFINE_STATIC_LOCAL(FilePath, gdata_mount_path,
-      (FilePath::FromUTF8Unsafe(kGDataMountPointPath)));
+      (FilePath::FromUTF8Unsafe(kDriveMountPointPath)));
   return gdata_mount_path;
 }
 
-const std::string& GetGDataMountPointPathAsString() {
+const std::string& GetDriveMountPointPathAsString() {
   CR_DEFINE_STATIC_LOCAL(std::string, gdata_mount_path_string,
-      (kGDataMountPointPath));
+      (kDriveMountPointPath));
   return gdata_mount_path_string;
 }
 
 const FilePath& GetSpecialRemoteRootPath() {
   CR_DEFINE_STATIC_LOCAL(FilePath, gdata_mount_path,
-      (FilePath::FromUTF8Unsafe(kGDataSpecialRootPath)));
+      (FilePath::FromUTF8Unsafe(kDriveSpecialRootPath)));
   return gdata_mount_path;
 }
 
 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,
+void ModifyDriveFileResourceUrl(Profile* profile,
                                 const FilePath& drive_cache_path,
                                 GURL* url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileSystemInterface* file_system = GetDriveFileSystem(profile);
   if (!file_system)
     return;
   DriveCache* cache = GetDriveCache(profile);
   if (!cache)
     return;
@@ skipping 17 matching lines @@
         drive_cache_path.BaseName().RemoveExtension().AsUTF8Unsafe();
     file_system->GetEntryInfoByResourceId(
         resource_id,
         base::Bind(&OnGetEntryInfoByResourceId,
                    profile,
                    resource_id));
     *url = GURL();
   }
 }
 
-bool IsUnderGDataMountPoint(const FilePath& path) {
-  return GetGDataMountPointPath() == path ||
-         GetGDataMountPointPath().IsParent(path);
+bool IsUnderDriveMountPoint(const FilePath& path) {
+  return GetDriveMountPointPath() == path ||
+         GetDriveMountPointPath().IsParent(path);
 }
 
-FilePath ExtractGDataPath(const FilePath& path) {
-  if (!IsUnderGDataMountPoint(path))
+FilePath ExtractDrivePath(const FilePath& path) {
+  if (!IsUnderDriveMountPoint(path))
     return FilePath();
 
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
 
   // -1 to include 'drive'.
   FilePath extracted;
-  for (size_t i = arraysize(kGDataMountPointPathComponents) - 1;
+  for (size_t i = arraysize(kDriveMountPointPathComponents) - 1;
        i < components.size(); ++i) {
     extracted = extracted.Append(components[i]);
   }
   return extracted;
 }
 
 void InsertDriveCachePathsPermissions(
     Profile* profile,
     scoped_ptr<std::vector<FilePath> > gdata_paths,
     std::vector<std::pair<FilePath, int> >* cache_paths,
@@ skipping 91 matching lines @@
   *md5 = (extension_count > 0) ? extensions[extension_count - 1] :
                                  std::string();
   *extra_extension = (extension_count > 1) ? extensions[extension_count - 2] :
                                              std::string();
 }
 
 void PrepareWritableFileAndRun(Profile* profile,
                                const FilePath& path,
                                const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (IsUnderGDataMountPoint(path)) {
+  if (IsUnderDriveMountPoint(path)) {
     FileWriteHelper* file_write_helper = GetFileWriteHelper(profile);
     if (!file_write_helper)
       return;
-    FilePath remote_path(ExtractGDataPath(path));
+    FilePath remote_path(ExtractDrivePath(path));
     file_write_helper->PrepareWritableFileAndRun(remote_path, callback);
   } else {
     if (!callback.is_null()) {
       content::BrowserThread::GetBlockingPool()->PostTask(
           FROM_HERE, base::Bind(callback, DRIVE_FILE_OK, path));
     }
   }
 }
 
 DriveFileError GDataToDriveFileError(GDataErrorCode status) {
@@ skipping 11 matching lines @@
       return DRIVE_FILE_ERROR_ABORT;
     case GDATA_NO_CONNECTION:
       return DRIVE_FILE_ERROR_NO_CONNECTION;
     default:
       return DRIVE_FILE_ERROR_FAILED;
   }
 }
 
 }  // namespace util
 }  // namespace gdata