Rename GData* to Drive* in gdata.proto

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>
@@ skipping 179 matching lines @@
                 GetDocumentsParams* params,
                 GDataFileError error);
 
   // Part of TransferFileFromLocalToRemote(). Called after
   // GetEntryInfoByPath() is complete.
   void TransferFileFromLocalToRemoteAfterGetEntryInfo(
       const FilePath& local_src_file_path,
       const FilePath& remote_dest_file_path,
       const FileOperationCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Initiates transfer of |local_file_path| with |resource_id| to
   // |remote_dest_file_path|. |local_file_path| must be a file from the local
   // file system, |remote_dest_file_path| is the virtual destination path within
   // gdata file system. If |resource_id| is a non-empty string, the transfer is
   // handled by CopyDocumentToDirectory. Otherwise, the transfer is handled by
   // TransferRegularFile.
   //
   // Must be called from *UI* thread. |callback| is run on the calling thread.
   // |callback| must not be null.
@@ skipping 16 matching lines @@
   // First, FindEntryByPathAsyncOnUIThread is called and the result is returned
   // to OnGetEntryInfoForCreateFile. By using the information, CreateFile deals
   // with the cases when an entry already existed at the path. If there was no
   // entry, a new empty file is uploaded, and when it finishes
   // DidUploadForCreateBrandNewFile does the final clean up.
   // |callback| must not be null.
   void OnGetEntryInfoForCreateFile(const FilePath& file_path,
                                    bool is_exclusive,
                                    const FileOperationCallback& callback,
                                    GDataFileError result,
-                                   scoped_ptr<GDataEntryProto> entry_proto);
+                                   scoped_ptr<DriveEntryProto> entry_proto);
   void DoUploadForCreateBrandNewFile(const FilePath& remote_path,
                                      FilePath* local_path,
                                      const FileOperationCallback& callback);
   void DidUploadForCreateBrandNewFile(const FilePath& local_path,
                                       const FileOperationCallback& callback,
                                       GDataFileError result);
 
   // Invoked upon completion of GetEntryInfoByPath initiated by
   // GetFileByPath. It then continues to invoke GetResolvedFileByPath.
   void OnGetEntryInfoCompleteForGetFileByPath(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
       const GetContentCallback& get_content_callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> file_info);
+      scoped_ptr<DriveEntryProto> file_info);
 
   // Invoked upon completion of GetEntryInfoByPath initiated by OpenFile.
   // It then continues to invoke GetResolvedFileByPath and proceeds to
   // OnGetFileCompleteForOpenFile.
   void OnGetEntryInfoCompleteForOpenFile(
       const FilePath& file_path,
       const OpenFileCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> file_info);
+      scoped_ptr<DriveEntryProto> file_info);
 
   // Invoked at the last step of OpenFile. It removes |file_path| from the
   // current set of opened files if |result| is an error, and then invokes the
   // |callback| function.
   void OnOpenFileFinished(const FilePath& file_path,
                           const OpenFileCallback& callback,
                           GDataFileError result,
                           const FilePath& cache_file_path);
 
   // Invoked during the process of CloseFile. What is done here is as follows:
   // 1) Gets resource_id and md5 of the entry at |file_path|.
   // 2) Commits the modification to the cache system.
   // 3) Removes the |file_path| from the remembered set of opened files.
   // 4) Invokes the user-supplied |callback|.
   // |callback| must not be null.
   void CloseFileOnUIThreadAfterGetEntryInfo(
       const FilePath& file_path,
       const FileOperationCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
   void CloseFileOnUIThreadAfterCommitDirtyInCache(
       const FileOperationCallback& callback,
       GDataFileError error,
       const std::string& resource_id,
       const std::string& md5);
   void CloseFileOnUIThreadFinalize(const FilePath& file_path,
                                    const FileOperationCallback& callback,
                                    GDataFileError result);
 
   // Invoked upon completion of GetFileByPath initiated by Copy. If
@@ skipping 56 matching lines @@
   // |callback| must not be null.
   void Rename(const FilePath& file_path,
               const FilePath::StringType& new_name,
               const FileMoveCallback& callback);
 
   // Part of Rename(). Called after GetEntryInfoByPath() is complete.
   void RenameAfterGetEntryInfo(const FilePath& file_path,
                                const FilePath::StringType& new_name,
                                const FileMoveCallback& callback,
                                GDataFileError error,
-                               scoped_ptr<GDataEntryProto> entry_proto);
+                               scoped_ptr<DriveEntryProto> entry_proto);
 
   // Moves a file or directory at |file_path| in the root directory to
   // another directory at |dir_path|. This function does nothing if
   // |dir_path| points to the root directory.
   //
   // Can be called from UI thread. |callback| is run on the calling thread.
   // |callback| must not be null.
   void MoveEntryFromRootDirectory(const FilePath& dir_path,
                                   const FileOperationCallback& callback,
                                   GDataFileError error,
@@ skipping 89 matching lines @@
   // Callback for handling file downloading requests.
   void OnFileDownloaded(const GetFileFromCacheParams& params,
                         GDataErrorCode status,
                         const GURL& content_url,
                         const FilePath& downloaded_file_path);
 
   // Unpins file if cache entry is pinned.
   void UnpinIfPinned(const std::string& resource_id,
                      const std::string& md5,
                      bool success,
-                     const GDataCacheEntry& cache_entry);
+                     const DriveCacheEntry& cache_entry);
 
   // Similar to OnFileDownloaded() but takes |has_enough_space| so we report
   // an error in case we don't have enough disk space.
   void OnFileDownloadedAndSpaceChecked(const GetFileFromCacheParams& params,
                                        GDataErrorCode status,
                                        const GURL& content_url,
                                        const FilePath& downloaded_file_path,
                                        bool* has_enough_space);
 
   // Callback for handling internal StoreToCache() calls after downloading
@@ skipping 100 matching lines @@
                                  int64* file_size,
                                  std::string* content_type);
 
   // Part of StartFileUploadOnUIThread(). Called after GetEntryInfoByPath()
   // is complete.
   void StartFileUploadOnUIThreadAfterGetEntryInfo(
       const StartFileUploadParams& params,
       int64 file_size,
       std::string content_type,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Cache intermediate callbacks, that run on calling thread, for above cache
   // tasks that were run on blocking pool.
 
   // Helper function for internally handling responses from
   // GetFileFromCacheByResourceIdAndMd5() calls during processing of
   // GetFileByPath() request.
   void OnGetFileFromCache(const GetFileFromCacheParams& params,
                           GDataFileError error,
                           const std::string& resource_id,
@@ skipping 28 matching lines @@
   // 1) Called when the feed is loaded.
   // 2) Called when an entry is found.
   // |callback| must not be null.
   void GetEntryInfoByPathOnUIThreadAfterLoad(
       const FilePath& file_path,
       const GetEntryInfoCallback& callback,
       GDataFileError error);
   void GetEntryInfoByPathOnUIThreadAfterGetEntry(
       const GetEntryInfoCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of ReadDirectoryByPathOnUIThread()
   // 1) Called when the feed is loaded.
   // 2) Called when an entry is found.
   // |callback| must not be null.
   void ReadDirectoryByPathOnUIThreadAfterLoad(
       const FilePath& file_path,
       const ReadDirectoryWithSettingCallback& callback,
       GDataFileError error);
   void ReadDirectoryByPathOnUIThreadAfterRead(
       const ReadDirectoryWithSettingCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProtoVector> entries);
+      scoped_ptr<DriveEntryProtoVector> entries);
 
   // Loads the feed from the cache or the server if not yet loaded. Runs
   // |callback| upon the completion with the error code.
   // |callback| must not be null.
   void LoadFeedIfNeeded(const FileOperationCallback& callback);
 
   // Gets |file_path| from the file system after the file info is already
   // resolved with GetEntryInfoByPath(). This function is called by
   // OnGetEntryInfoCompleteForGetFileByPath and
   // OnGetEntryInfoCompleteForOpenFile.
   void GetResolvedFileByPath(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
       const GetContentCallback& get_content_callback,
       GDataFileError error,
-      const GDataEntryProto* entry_proto);
+      const DriveEntryProto* entry_proto);
 
   // Called when GDataCache::GetFileOnUIThread() is completed for
   // UpdateFileByResourceId().
   void OnGetFileCompleteForUpdateFile(const FileOperationCallback& callback,
                                       GDataFileError error,
                                       const std::string& resource_id,
                                       const std::string& md5,
                                       const FilePath& cache_file_path);
 
   // Callback for getting the size of the cache file in the blocking pool.
@@ skipping 101 matching lines @@
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result);
 
   // Part of RemoveOnUIThread(). Called after GetEntryInfoByPath() is
   // complete.
   void RemoveOnUIThreadAfterGetEntryInfo(
       const FilePath& file_path,
       bool is_recursive,
       const FileOperationCallback& callback,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of RequestDirectoryRefreshOnUIThread(). Called after
   // GetEntryInfoByPath() is complete.
   void RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
       const FilePath& file_path,
       GDataFileError error,
-      scoped_ptr<GDataEntryProto> entry_proto);
+      scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of GetEntryByResourceId and GetEntryByPath. Checks whether there is a
   // local dirty cache for the entry, and if there is, replace the
   // PlatformFileInfo part of the |entry_proto| with the locally modified info.
   // |callback| must not be null.
-  void CheckLocalModificationAndRun(scoped_ptr<GDataEntryProto> entry_proto,
+  void CheckLocalModificationAndRun(scoped_ptr<DriveEntryProto> entry_proto,
                                     const GetEntryInfoCallback& callback);
   void CheckLocalModificationAndRunAfterGetCacheEntry(
-      scoped_ptr<GDataEntryProto> entry_proto,
+      scoped_ptr<DriveEntryProto> entry_proto,
       const GetEntryInfoCallback& callback,
       bool success,
-      const GDataCacheEntry& cache_entry);
+      const DriveCacheEntry& cache_entry);
   void CheckLocalModificationAndRunAfterGetCacheFile(
-      scoped_ptr<GDataEntryProto> entry_proto,
+      scoped_ptr<DriveEntryProto> entry_proto,
       const GetEntryInfoCallback& callback,
       GDataFileError error,
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& local_cache_path);
   void CheckLocalModificationAndRunAfterGetFileInfo(
-      scoped_ptr<GDataEntryProto> entry_proto,
+      scoped_ptr<DriveEntryProto> entry_proto,
       const GetEntryInfoCallback& callback,
       base::PlatformFileInfo* file_info,
       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<GDataDirectoryService> directory_service_;
 
   // The profile hosts the GDataFileSystem via GDataSystemService.
   Profile* profile_;
@@ skipping 33 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_