Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_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_
 
 #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 GDataCacheEntry;
+class DriveCacheEntry;
 class GDataCacheMetadata;
 
 // 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,
@@ skipping 14 matching lines @@
     GetResourceIdsOfBacklogCallback;
 
 // Callback for GetResourceIdsOfExistingPinnedFilesOnUIThread.
 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 GDataCacheEntry& cache_entry)>
+typedef base::Callback<void(bool success, const DriveCacheEntry& cache_entry)>
     GetCacheEntryCallback;
 
 // GDataCache 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
 // threading model is enforced by AssertOnSequencedWorkerPool().
 //
 // TODO(hashimoto): Change threading model of this class to make public methods
@@ skipping 202 matching lines @@
   // Force a rescan of cache files, for testing.
   void ForceRescanOnUIThreadForTesting();
 
   // 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,
-                     GDataCacheEntry* entry);
+                     DriveCacheEntry* entry);
 
   // Factory methods for GDataCache.
   // |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(
       const FilePath& cache_root_path,
       base::SequencedTaskRunner* blocking_task_runner);
@@ skipping 12 matching lines @@
 
   // 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 GDataCacheEntry& cache_entry);
+      const DriveCacheEntry& cache_entry);
 
  private:
   GDataCache(const FilePath& cache_root_path,
              base::SequencedTaskRunner* blocking_task_runner);
   virtual ~GDataCache();
 
   // Checks whether the current thread is on the right sequenced worker pool
   // with the right sequence ID. If not, DCHECK will fail.
   void AssertOnSequencedWorkerPool();
 
@@ skipping 95 matching lines @@
   // Runs callback and notifies the observers when file is committed.
   void OnCommitDirty(GDataFileError* error,
                      const std::string& resource_id,
                      const std::string& md5,
                      const CacheOperationCallback& callback);
 
   // Helper function to implement GetCacheEntryOnUIThread().
   void GetCacheEntryHelper(const std::string& resource_id,
                            const std::string& md5,
                            bool* success,
-                           GDataCacheEntry* cache_entry);
+                           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.
   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_;
@@ skipping 24 matching lines @@
 };
 
 // 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_