Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/gdata_file_system.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_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/platform_file.h"
 #include "base/timer.h"
 #include "chrome/browser/api/prefs/pref_change_registrar.h"
+#include "chrome/browser/chromeos/gdata/drive_cache.h"
 #include "chrome/browser/chromeos/gdata/drive_resource_metadata.h"
-#include "chrome/browser/chromeos/gdata/gdata_cache.h"
 #include "chrome/browser/chromeos/gdata/gdata_errorcode.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_feed_loader.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_feed_processor.h"
 #include "content/public/browser/notification_observer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace gdata {
 
 class DriveServiceInterface;
 class DriveWebAppsRegistryInterface;
 class GDataUploaderInterface;
 class GDataWapiFeedLoader;
 struct UploadFileInfo;
 
 // The production implementation of GDataFileSystemInterface.
 class GDataFileSystem : public GDataFileSystemInterface,
                         public GDataWapiFeedLoader::Observer,
                         public content::NotificationObserver {
  public:
   GDataFileSystem(Profile* profile,
-                  GDataCache* cache,
+                  DriveCache* cache,
                   DriveServiceInterface* drive_service,
                   GDataUploaderInterface* uploader,
                   DriveWebAppsRegistryInterface* webapps_registry,
                   base::SequencedTaskRunner* blocking_task_runner);
   virtual ~GDataFileSystem();
 
   // GDataFileSystem overrides.
   virtual void Initialize() OVERRIDE;
   virtual void AddObserver(
       GDataFileSystemInterface::Observer* observer) OVERRIDE;
@@ skipping 56 matching lines @@
       const FilePath& file_path,
       const ReadDirectoryWithSettingCallback& callback) OVERRIDE;
   virtual void RequestDirectoryRefresh(
       const FilePath& file_path) OVERRIDE;
   virtual void GetAvailableSpace(
       const GetAvailableSpaceCallback& callback) OVERRIDE;
   virtual void AddUploadedFile(UploadMode upload_mode,
                                const FilePath& virtual_dir_path,
                                scoped_ptr<DocumentEntry> entry,
                                const FilePath& file_content_path,
-                               GDataCache::FileOperationType cache_operation,
+                               DriveCache::FileOperationType cache_operation,
                                const base::Closure& callback) OVERRIDE;
   virtual void UpdateEntryData(const std::string& resource_id,
                                const std::string& md5,
                                scoped_ptr<DocumentEntry> entry,
                                const FilePath& file_content_path,
                                const base::Closure& callback) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
@@ skipping 536 matching lines @@
   // Part of UpdateFileByResourceId(). Called when
   // DriveDirectory::GetEntryInfoByResourceId() is complete.
   // |callback| must not be null.
   void UpdateFileByEntryInfo(
       const FileOperationCallback& callback,
       GDataFileError error,
       const FilePath& /* drive_file_path */,
       scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of UpdateFileByResourceId().
-  // Called when GDataCache::GetFileOnUIThread() is completed for
+  // Called when DriveCache::GetFileOnUIThread() is completed for
   // UpdateFileByResourceId().
   // |callback| must not be null.
   void OnGetFileCompleteForUpdateFile(const FileOperationCallback& callback,
                                       GDataFileError error,
                                       const std::string& resource_id,
                                       const std::string& md5,
                                       const FilePath& cache_file_path);
 
   // Part of UpdateFileByResourceId().
   // Callback for getting the size of the cache file in the blocking pool.
@@ skipping 75 matching lines @@
       const ReadDirectoryWithSettingCallback& callback);
   void RequestDirectoryRefreshOnUIThread(const FilePath& file_path);
   void OnRequestDirectoryRefresh(const FilePath& directory_path,
                                  GetDocumentsParams* params,
                                  GDataFileError error);
   void GetAvailableSpaceOnUIThread(const GetAvailableSpaceCallback& callback);
   void AddUploadedFileOnUIThread(UploadMode upload_mode,
                                  const FilePath& virtual_dir_path,
                                  scoped_ptr<DocumentEntry> entry,
                                  const FilePath& file_content_path,
-                                 GDataCache::FileOperationType cache_operation,
+                                 DriveCache::FileOperationType cache_operation,
                                  const base::Closure& callback);
   void UpdateEntryDataOnUIThread(const std::string& resource_id,
                                  const std::string& md5,
                                  scoped_ptr<DocumentEntry> entry,
                                  const FilePath& file_content_path,
                                  const base::Closure& callback);
 
   // Part of CopyOnUIThread(). Called after GetEntryInfoPairByPaths() is
   // complete. |callback| must not be null.
   void CopyOnUIThreadAfterGetEntryInfoPair(
@@ skipping 49 matching lines @@
       bool* get_file_info_result);
 
   // All members should be accessed only on UI thread. Do not post tasks to
   // other threads with base::Unretained(this).
   scoped_ptr<DriveResourceMetadata> resource_metadata_;
 
   // The profile hosts the GDataFileSystem via GDataSystemService.
   Profile* profile_;
 
   // The cache owned by GDataSystemService.
-  GDataCache* cache_;
+  DriveCache* cache_;
 
   // The uploader owned by GDataSystemService.
   GDataUploaderInterface* uploader_;
 
   // The document service owned by GDataSystemService.
   DriveServiceInterface* drive_service_;
 
   // The webapps registry owned by GDataSystemService.
   DriveWebAppsRegistryInterface* webapps_registry_;
 
@@ skipping 20 matching lines @@
   // invalidate the weak pointers before any other members are destroyed.
   base::WeakPtrFactory<GDataFileSystem> ui_weak_ptr_factory_;
   // Unlike other classes, we need this as we need this to redirect a task
   // from IO thread to UI thread.
   base::WeakPtr<GDataFileSystem> ui_weak_ptr_;
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_