drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/chromeos/drive/drive_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_DRIVE_DRIVE_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_SYSTEM_H_
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/gdata_wapi_feed_loader_observer.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "content/public/browser/notification_observer.h"
 
 class PrefChangeRegistrar;
 
 namespace base {
 struct PlatformFileInfo;
 class SequencedTaskRunner;
 }
 
 namespace gdata {
+class DocumentFeed;
+}
 
-class DocumentFeed;
+namespace drive {
+
 class DriveFileSystemObserver;
 class DriveFunctionRemove;
 class DriveResourceMetadata;
 class DriveServiceInterface;
 class DriveScheduler;
 class DriveUploaderInterface;
 class DriveWebAppsRegistryInterface;
 class GDataWapiFeedLoader;
 struct LoadFeedParams;
 
@@ skipping 55 matching lines @@
   virtual void CreateDirectory(const FilePath& directory_path,
                                bool is_exclusive,
                                bool is_recursive,
                                const FileOperationCallback& callback) OVERRIDE;
   virtual void CreateFile(const FilePath& file_path,
                           bool is_exclusive,
                           const FileOperationCallback& callback) OVERRIDE;
   virtual void GetFileByPath(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback) OVERRIDE;
+      const gdata::GetContentCallback& get_content_callback) OVERRIDE;
   virtual void GetFileByResourceId(
       const std::string& resource_id,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback) OVERRIDE;
+      const gdata::GetContentCallback& get_content_callback) OVERRIDE;
   virtual void UpdateFileByResourceId(
       const std::string& resource_id,
       const FileOperationCallback& callback) OVERRIDE;
   virtual void GetEntryInfoByPath(
       const FilePath& file_path,
       const GetEntryInfoCallback& callback) OVERRIDE;
   virtual void ReadDirectoryByPath(
       const FilePath& directory_path,
       const ReadDirectoryWithSettingCallback& callback) OVERRIDE;
   virtual void RequestDirectoryRefresh(
       const FilePath& directory_path) OVERRIDE;
   virtual void GetAvailableSpace(
       const GetAvailableSpaceCallback& callback) OVERRIDE;
-  virtual void AddUploadedFile(UploadMode upload_mode,
+  virtual void AddUploadedFile(gdata::UploadMode upload_mode,
                                const FilePath& directory_path,
-                               scoped_ptr<DocumentEntry> doc_entry,
+                               scoped_ptr<gdata::DocumentEntry> doc_entry,
                                const FilePath& file_content_path,
                                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,
+                               scoped_ptr<gdata::DocumentEntry> entry,
                                const FilePath& file_content_path,
                                const base::Closure& callback) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // GDataWapiFeedLoader::Observer overrides.
   // Used to propagate events from GDataWapiFeedLoader.
   virtual void OnDirectoryChanged(const FilePath& directory_path) OVERRIDE;
   virtual void OnDocumentFeedFetched(int num_accumulated_entries) OVERRIDE;
   virtual void OnFeedFromServerLoaded() OVERRIDE;
 
   DriveResourceMetadata* ResourceMetadata() { return resource_metadata_.get(); }
 
   // Used in tests to load the root feed from the cache.
   void LoadRootFeedFromCacheForTesting();
 
   // Used in tests to update the file system from |feed_list|.
   // See also the comment at GDataWapiFeedLoader::UpdateFromFeed().
   DriveFileError UpdateFromFeedForTesting(
-      const ScopedVector<DocumentFeed>& feed_list,
+      const ScopedVector<gdata::DocumentFeed>& feed_list,
       int64 start_changestamp,
       int64 root_feed_changestamp);
 
  private:
   friend class DriveFileSystemTest;
   FRIEND_TEST_ALL_PREFIXES(DriveFileSystemTest,
                            FindFirstMissingParentDirectory);
   // Defines possible search results of FindFirstMissingParentDirectory().
   enum FindFirstMissingParentDirectoryError {
     // Target directory found, it's not a directory.
@@ skipping 144 matching lines @@
                                       const FileOperationCallback& callback,
                                       DriveFileError result);
 
   // Invoked upon completion of GetEntryInfoByPath initiated by
   // GetFileByPath. It then continues to invoke GetResolvedFileByPath.
   // |get_file_callback| must not be null.
   // |get_content_callback| may be null.
   void OnGetEntryInfoCompleteForGetFileByPath(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback,
+      const gdata::GetContentCallback& get_content_callback,
       DriveFileError error,
       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,
       DriveFileError error,
@@ skipping 100 matching lines @@
   //
   // Must be called on UI thread.
   void OnMarkDirtyInCacheCompleteForOpenFile(const OpenFileCallback& callback,
                                              DriveFileError error,
                                              const FilePath& cache_file_path);
 
   // Callback for handling document copy attempt.
   // |callback| must not be null.
   void OnCopyDocumentCompleted(const FilePath& dir_path,
                                const FileOperationCallback& callback,
-                               GDataErrorCode status,
+                               gdata::GDataErrorCode status,
                                scoped_ptr<base::Value> data);
 
   // Callback for handling account metadata fetch.
   void OnGetAvailableSpace(const GetAvailableSpaceCallback& callback,
-                           GDataErrorCode status,
+                           gdata::GDataErrorCode status,
                            scoped_ptr<base::Value> data);
 
   // Callback for handling Drive V2 about resource fetch.
   void OnGetAboutResource(const GetAvailableSpaceCallback& callback,
-                          GDataErrorCode status,
+                          gdata::GDataErrorCode status,
                           scoped_ptr<base::Value> data);
 
   // Callback for handling directory create requests. Adds the directory
   // represented by |created_entry| to the local filesystem.
   void AddNewDirectory(const CreateDirectoryParams& params,
-                       GDataErrorCode status,
+                       gdata::GDataErrorCode status,
                        scoped_ptr<base::Value> created_entry);
 
   // Callback for DriveResourceMetadata::AddEntryToDirectory. Continues the
   // recursive creation of a directory path by calling CreateDirectory again.
   void ContinueCreateDirectory(
       const CreateDirectoryParams& params,
       DriveFileError error,
       const FilePath& moved_directory_path);
 
   // Callback for handling file downloading requests.
   void OnFileDownloaded(const GetFileFromCacheParams& params,
-                        GDataErrorCode status,
+                        gdata::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 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,
+                                       gdata::GDataErrorCode status,
                                        const GURL& content_url,
                                        const FilePath& downloaded_file_path,
                                        bool* has_enough_space);
 
   // Callback for handling internal StoreToCache() calls after downloading
   // file content.
   void OnDownloadStoredToCache(DriveFileError error,
                                const std::string& resource_id,
                                const std::string& md5);
 
   // Moves entry specified by |file_path| to the directory specified by
   // |dir_path| and calls |callback| asynchronously.
   // |callback| must not be null.
   void MoveEntryToDirectory(const FilePath& file_path,
                             const FilePath& directory_path,
                             const FileMoveCallback& callback,
-                            GDataErrorCode status,
+                            gdata::GDataErrorCode status,
                             const GURL& document_url);
 
   // Callback when an entry is moved to another directory on the client side.
   // Notifies the directory change and runs |callback|.
   // |callback| must not be null.
   void NotifyAndRunFileOperationCallback(
       const FileOperationCallback& callback,
       DriveFileError error,
       const FilePath& moved_file_path);
 
@@ skipping 43 matching lines @@
   // |callback| must not be null.
   void NotifyInitialLoadFinishedAndRun(const FileOperationCallback& callback,
                                        DriveFileError error);
 
   // Helper function that completes bookkeeping tasks related to
   // completed file transfer.
   void OnTransferCompleted(const FileOperationCallback& callback,
                            DriveFileError error,
                            const FilePath& drive_path,
                            const FilePath& file_path,
-                           scoped_ptr<DocumentEntry> document_entry);
+                           scoped_ptr<gdata::DocumentEntry> document_entry);
 
   // Kicks off file upload once it receives |file_size| and |content_type|.
   void StartFileUploadOnUIThread(const StartFileUploadParams& params,
                                  DriveFileError* error,
                                  int64* file_size,
                                  std::string* content_type);
 
   // Part of StartFileUploadOnUIThread(). Called after GetEntryInfoByPath()
   // is complete.
   void StartFileUploadOnUIThreadAfterGetEntryInfo(
@@ skipping 11 matching lines @@
   // GetFileByPath() request.
   void OnGetFileFromCache(const GetFileFromCacheParams& params,
                           DriveFileError error,
                           const FilePath& cache_file_path);
 
   // Callback for |drive_service_->GetDocumentEntry|.
   // It is called before file download. If GetDocumentEntry was successful,
   // file download procedure is started for the file. The file is downloaded
   // from the content url extracted from the fetched metadata.
   void OnGetDocumentEntry(const GetFileFromCacheParams& params,
-                          GDataErrorCode status,
+                          gdata::GDataErrorCode status,
                           scoped_ptr<base::Value> data);
 
   // Check available space using file size from the fetched metadata. Called
   // from OnGetDocumentEntry after RefreshFile is complete.
   void CheckForSpaceBeforeDownload(
       const GetFileFromCacheParams& params,
       int64 file_size,
       const GURL& content_url,
       DriveFileError error,
       const FilePath& drive_file_path,
@@ skipping 44 matching lines @@
   void LoadFeedIfNeeded(const FileOperationCallback& callback);
 
   // Gets the file at |file_path| from the cache (if found in the cache),
   // or the server (if not found in the cache) after the file info is
   // already resolved with GetEntryInfoByPath() or GetEntryInfoByResourceId().
   // |get_file_callback| must not be null.
   // |get_content_callback| may be null.
   void GetResolvedFileByPath(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback,
+      const gdata::GetContentCallback& get_content_callback,
       scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of UpdateFileByResourceId(). Called when
   // DriveDirectory::GetEntryInfoByResourceId() is complete.
   // |callback| must not be null.
   void UpdateFileByEntryInfo(
       const FileOperationCallback& callback,
       DriveFileError error,
       const FilePath& drive_file_path,
       scoped_ptr<DriveEntryProto> entry_proto);
@@ skipping 20 matching lines @@
       int64* file_size);
 
   // Part of UpdateFileByResourceId().
   // Called when DriveUploader::UploadUpdatedFile() is completed for
   // UpdateFileByResourceId().
   // |callback| must not be null.
   void OnUpdatedFileUploaded(const FileOperationCallback& callback,
                              DriveFileError error,
                              const FilePath& gdata_path,
                              const FilePath& file_path,
-                             scoped_ptr<DocumentEntry> document_entry);
+                             scoped_ptr<gdata::DocumentEntry> document_entry);
 
   // The following functions are used to forward calls to asynchronous public
   // member functions to UI thread.
   void SearchAsyncOnUIThread(const std::string& search_query,
                              const GURL& next_feed,
                              const SearchCallback& callback);
   void OpenFileOnUIThread(const FilePath& file_path,
                           const OpenFileCallback& callback);
   void CloseFileOnUIThread(const FilePath& file_path,
                            const FileOperationCallback& callback);
   void CopyOnUIThread(const FilePath& src_file_path,
                       const FilePath& dest_file_path,
                       const FileOperationCallback& callback);
   void MoveOnUIThread(const FilePath& src_file_path,
                       const FilePath& dest_file_path,
                       const FileOperationCallback& callback);
   void RemoveOnUIThread(const FilePath& file_path,
                         bool is_recursive,
                         const FileOperationCallback& callback);
   void CreateDirectoryOnUIThread(const FilePath& directory_path,
                                  bool is_exclusive,
                                  bool is_recursive,
                                  const FileOperationCallback& callback);
   void CreateFileOnUIThread(const FilePath& file_path,
                             bool is_exclusive,
                             const FileOperationCallback& callback);
   void GetFileByPathOnUIThread(
       const FilePath& file_path,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback);
+      const gdata::GetContentCallback& get_content_callback);
   void GetFileByResourceIdOnUIThread(
       const std::string& resource_id,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback);
+      const gdata::GetContentCallback& get_content_callback);
   void UpdateFileByResourceIdOnUIThread(const std::string& resource_id,
                                         const FileOperationCallback& callback);
   void GetEntryInfoByPathOnUIThread(const FilePath& file_path,
                                     const GetEntryInfoCallback& callback);
   void GetEntryInfoByResourceIdOnUIThread(
       const std::string& resource_id,
       const GetEntryInfoWithFilePathCallback& callback);
   void ReadDirectoryByPathOnUIThread(
       const FilePath& file_path,
       const ReadDirectoryWithSettingCallback& callback);
   void RequestDirectoryRefreshOnUIThread(const FilePath& file_path);
   void OnRequestDirectoryRefresh(const FilePath& directory_path,
                                  scoped_ptr<LoadFeedParams> params,
                                  DriveFileError error);
   void GetAvailableSpaceOnUIThread(const GetAvailableSpaceCallback& callback);
-  void AddUploadedFileOnUIThread(UploadMode upload_mode,
+  void AddUploadedFileOnUIThread(gdata::UploadMode upload_mode,
                                  const FilePath& directory_path,
-                                 scoped_ptr<DocumentEntry> doc_entry,
+                                 scoped_ptr<gdata::DocumentEntry> doc_entry,
                                  const FilePath& file_content_path,
                                  DriveCache::FileOperationType cache_operation,
                                  const base::Closure& callback);
   void UpdateEntryDataOnUIThread(const UpdateEntryParams& params,
-                                 scoped_ptr<DocumentEntry> entry);
+                                 scoped_ptr<gdata::DocumentEntry> entry);
 
   // Part of CreateDirectory(). Called after
   // FindFirstMissingParentDirectory() is complete.
   // |callback| must not be null.
   void CreateDirectoryAfterFindFirstMissingPath(
       const FilePath& directory_path,
       bool is_exclusive,
       bool is_recursive,
       const FileOperationCallback& callback,
       const FindFirstMissingParentDirectoryResult& result);
 
   // Part of GetEntryInfoByResourceId(). Called after
   // DriveResourceMetadata::GetEntryInfoByResourceId() is complete.
   // |callback| must not be null.
   void GetEntryInfoByResourceIdAfterGetEntry(
       const GetEntryInfoWithFilePathCallback& callback,
       DriveFileError error,
       const FilePath& file_path,
       scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of GetFileByResourceIdOnUIThread(). Called after
   // DriveResourceMetadata::GetEntryInfoByResourceId() is complete.
   // |get_file_callback| must not be null.
   // |get_content_callback| may be null.
   void GetFileByResourceIdAfterGetEntry(
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback,
+      const gdata::GetContentCallback& get_content_callback,
       DriveFileError error,
       const FilePath& file_path,
       scoped_ptr<DriveEntryProto> entry_proto);
 
   // Part of CopyOnUIThread(). Called after GetEntryInfoPairByPaths() is
   // complete. |callback| must not be null.
   void CopyOnUIThreadAfterGetEntryInfoPair(
     const FilePath& dest_file_path,
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result);
@@ skipping 78 matching lines @@
 
   // WeakPtrFactory and WeakPtr bound to the UI thread.
   // Note: These should remain the last member so they'll be destroyed and
   // invalidate the weak pointers before any other members are destroyed.
   base::WeakPtrFactory<DriveFileSystem> 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<DriveFileSystem> ui_weak_ptr_;
 };
 
-}  // namespace gdata
+}  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_SYSTEM_H_