Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/drive_cache.h

 // 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.
 
-#ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
-#define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
+#ifndef CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_CACHE_H_
+#define CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_CACHE_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/platform_file.h"
 #include "chrome/browser/chromeos/gdata/gdata_errorcode.h"
 
 class Profile;
 
 namespace base {
 
 class SequencedTaskRunner;
 
 }  // namespace base
 
 namespace gdata {
 
 class DriveCacheEntry;
-class GDataCacheMetadata;
+class DriveCacheMetadata;
 
 // Callback for SetMountedStateOnUIThread and ClearAllOnUIThread.
 typedef base::Callback<void(GDataFileError error,
                             const FilePath& file_path)>
     ChangeCacheStateCallback;
 
 // Callback for completion of cache operation.
 typedef base::Callback<void(GDataFileError error,
                             const std::string& resource_id,
                             const std::string& md5)> CacheOperationCallback;
@@ skipping 16 matching lines @@
 typedef base::Callback<void(const std::vector<std::string>& resource_ids)>
     GetResourceIdsCallback;
 
 // Callback for GetCacheEntryOnUIThread.
 // |success| indicates if the operation was successful.
 // |cache_entry| is the obtained cache entry. On failure, |cache_state| is
 // set to TEST_CACHE_STATE_NONE.
 typedef base::Callback<void(bool success, const DriveCacheEntry& cache_entry)>
     GetCacheEntryCallback;
 
-// GDataCache is used to maintain cache states of GDataFileSystem.
+// DriveCache is used to maintain cache states of GDataFileSystem.
 //
 // All non-static public member functions, unless mentioned otherwise (see
 // GetCacheFilePath() for example), should be called from the sequenced
-// worker pool with the sequence token set by CreateGDataCacheOnUIThread(). This
+// worker pool with the sequence token set by CreateDriveCacheOnUIThread(). This
 // threading model is enforced by AssertOnSequencedWorkerPool().
 //
 // TODO(hashimoto): Change threading model of this class to make public methods
 // being called on UI thread unless mentioned otherwise. crbug.com/132926
-class GDataCache {
+class DriveCache {
  public:
   // Enum defining GCache subdirectory location.
-  // This indexes into |GDataCache::cache_paths_| vector.
+  // This indexes into |DriveCache::cache_paths_| vector.
   enum CacheSubDirectoryType {
     CACHE_TYPE_META = 0,       // Downloaded feeds.
     CACHE_TYPE_PINNED,         // Symlinks to files in persistent dir that are
                                // pinned, or to /dev/null for non-existent
                                // files.
     CACHE_TYPE_OUTGOING,       // Symlinks to files in persistent or tmp dir to
                                // be uploaded.
     CACHE_TYPE_PERSISTENT,     // Files that are pinned or modified locally,
                                // not evictable, hopefully.
     CACHE_TYPE_TMP,            // Files that don't meet criteria to be in
@@ skipping 45 matching lines @@
   // Can be called on any thread.
   FilePath GetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             CacheSubDirectoryType sub_dir_type,
                             CachedFileOrigin file_orign) const;
 
   // Returns true if the given path is under gdata cache directory, i.e.
   // <user_profile_dir>/GCache/v1
   //
   // Can be called on any thread.
-  bool IsUnderGDataCacheDirectory(const FilePath& path) const;
+  bool IsUnderDriveCacheDirectory(const FilePath& path) const;
 
   // Adds observer.
   // Must be called on UI thread.
   void AddObserver(Observer* observer);
 
   // Removes observer.
   // Must be called on UI thread.
   void RemoveObserver(Observer* observer);
 
   // Gets the cache entry by the given resource ID and MD5.
@@ skipping 123 matching lines @@
 
   // Gets the cache entry for file corresponding to |resource_id| and |md5|
   // and returns true if entry exists in cache map.  Otherwise, returns false.
   // |md5| can be empty if only matching |resource_id| is desired, which may
   // happen when looking for pinned entries where symlinks' filenames have no
   // extension and hence no md5.
   bool GetCacheEntry(const std::string& resource_id,
                      const std::string& md5,
                      DriveCacheEntry* entry);
 
-  // Factory methods for GDataCache.
+  // Factory methods for DriveCache.
   // |pool| and |sequence_token| are used to assert that the functions are
   // called on the right sequenced worker pool with the right sequence token.
   //
   // For testing, the thread assertion can be disabled by passing NULL and
   // the default value of SequenceToken.
-  static GDataCache* CreateGDataCacheOnUIThread(
+  static DriveCache* CreateDriveCacheOnUIThread(
       const FilePath& cache_root_path,
       base::SequencedTaskRunner* blocking_task_runner);
 
   // Deletes the cache.
   void DestroyOnUIThread();
 
   // Gets the cache root path (i.e. <user_profile_dir>/GCache/v1) from the
   // profile.
   // TODO(satorux): Write a unit test for this.
   static FilePath GetCacheRootPath(Profile* profile);
 
   // Returns file paths for all the cache sub directories under
   // |cache_root_path|.
   static std::vector<FilePath> GetCachePaths(const FilePath& cache_root_path);
 
   // Creates cache directory and its sub-directories if they don't exist.
   // TODO(glotov): take care of this when the setup and cleanup part is
   // landed, noting that these directories need to be created for development
   // in linux box and unittest. (http://crosbug.com/27577)
   static bool CreateCacheDirectories(
       const std::vector<FilePath>& paths_to_create);
 
   // Returns the type of the sub directory where the cache file is stored.
   static CacheSubDirectoryType GetSubDirectoryType(
       const DriveCacheEntry& cache_entry);
 
  private:
-  GDataCache(const FilePath& cache_root_path,
+  DriveCache(const FilePath& cache_root_path,
              base::SequencedTaskRunner* blocking_task_runner);
-  virtual ~GDataCache();
+  virtual ~DriveCache();
 
   // Checks whether the current thread is on the right sequenced worker pool
   // with the right sequence ID. If not, DCHECK will fail.
   void AssertOnSequencedWorkerPool();
 
   // Initializes the cache.
   void Initialize();
 
   // Initializes the cache with in-memory cache for testing.
   // The in-memory cache is used since it's faster than the db.
@@ skipping 95 matching lines @@
 
   // Helper function to implement GetCacheEntryOnUIThread().
   void GetCacheEntryHelper(const std::string& resource_id,
                            const std::string& md5,
                            bool* success,
                            DriveCacheEntry* cache_entry);
 
   // The root directory of the cache (i.e. <user_profile_dir>/GCache/v1).
   const FilePath cache_root_path_;
   // Paths for all subdirectories of GCache, one for each
-  // GDataCache::CacheSubDirectoryType enum.
+  // DriveCache::CacheSubDirectoryType enum.
   const std::vector<FilePath> cache_paths_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
   // The cache state data. This member must be access only on the blocking pool.
-  scoped_ptr<GDataCacheMetadata> metadata_;
+  scoped_ptr<DriveCacheMetadata> metadata_;
 
   // List of observers, this member must be accessed on UI thread.
   ObserverList<Observer> observers_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<GDataCache> weak_ptr_factory_;
-  DISALLOW_COPY_AND_ASSIGN(GDataCache);
+  base::WeakPtrFactory<DriveCache> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(DriveCache);
 };
 
 
 // The minimum free space to keep. GDataFileSystem::GetFileByPath() returns
 // GDATA_FILE_ERROR_NO_SPACE if the available space is smaller than
 // this value.
 //
 // Copied from cryptohome/homedirs.h.
 // TODO(satorux): Share the constant.
 const int64 kMinFreeSpace = 512 * 1LL << 20;
 
 // Interface class used for getting the free disk space. Only for testing.
 class FreeDiskSpaceGetterInterface {
  public:
   virtual ~FreeDiskSpaceGetterInterface() {}
   virtual int64 AmountOfFreeDiskSpace() const = 0;
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
-#endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
+#endif  // CHROME_BROWSER_CHROMEOS_GDATA_DRIVE_CACHE_H_