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

chrome/browser/chromeos/extensions/file_browser_private_api.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_EXTENSIONS_FILE_BROWSER_PRIVATE_API_H_
 #define CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_BROWSER_PRIVATE_API_H_
 
 #include <map>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_error.h"
 #include "chrome/browser/chromeos/extensions/file_browser_event_router.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "googleurl/src/url_util.h"
 
 class GURL;
 
 namespace fileapi {
 class FileSystemContext;
 }
 
-namespace gdata {
+namespace drive {
 struct SearchResultInfo;
 struct DriveWebAppInfo;
 class DriveWebAppsRegistry;
 }
 
 namespace ui {
 struct SelectedFileInfo;
 }
 
 // Implements the chrome.fileBrowserPrivate.requestLocalFileSystem method.
@@ skipping 86 matching lines @@
  private:
   struct FileInfo {
     GURL file_url;
     FilePath file_path;
     std::string mime_type;
   };
   typedef std::vector<FileInfo> FileInfoList;
 
   // Typedef for holding a map from app_id to DriveWebAppInfo so
   // we can look up information on the apps.
-  typedef std::map<std::string, gdata::DriveWebAppInfo*> WebAppInfoMap;
+  typedef std::map<std::string, drive::DriveWebAppInfo*> WebAppInfoMap;
 
   // Look up apps in the registry, and collect applications that match the file
   // paths given. Returns the intersection of all available application ids in
   // |available_apps| and a map of application ID to the Drive web application
   // info collected in |app_info| so details can be collected later. The caller
   // takes ownership of the pointers in |app_info|.
   static void IntersectAvailableDriveTasks(
-      gdata::DriveWebAppsRegistry* registry,
+      drive::DriveWebAppsRegistry* registry,
       const FileInfoList& file_info_list,
       WebAppInfoMap* app_info,
       std::set<std::string>* available_apps);
 
   // Takes a map of app_id to application information in |app_info|, and the set
   // of |available_apps| and adds Drive tasks to the |result_list| for each of
   // the |available_apps|.  If a default task is set in the result list,
   // then |default_already_set| is set to true.
-  static void CreateDriveTasks(gdata::DriveWebAppsRegistry* registry,
+  static void CreateDriveTasks(drive::DriveWebAppsRegistry* registry,
                                const WebAppInfoMap& app_info,
                                const std::set<std::string>& available_apps,
                                const std::set<std::string>& default_apps,
                                ListValue* result_list,
                                bool* default_already_set);
 
   // Looks in the preferences and finds any of the available apps that are
   // also listed as default apps for any of the files in the info list.
   void FindDefaultDriveTasks(const FileInfoList& file_info_list,
                              const std::set<std::string>& available_apps,
@@ skipping 161 matching lines @@
   virtual bool RunImpl() OVERRIDE;
 
  private:
   // A callback method to handle the result of
   // GetLocalPathsOnFileThreadAndRunCallbackOnUIThread.
   void GetLocalPathsResponseOnUIThread(const std::string& mount_type_str,
                                        const SelectedFileInfoList& files);
   // A callback method to handle the result of SetMountedState.
   void OnMountedStateSet(const std::string& mount_type,
                          const FilePath::StringType& file_name,
-                         gdata::DriveFileError error,
+                         drive::DriveFileError error,
                          const FilePath& file_path);
 };
 
 // Unmounts selected device. Expects mount point path as an argument.
 class RemoveMountFunction : public FileBrowserFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("fileBrowserPrivate.removeMount");
 
   RemoveMountFunction();
 
@@ skipping 51 matching lines @@
   virtual ~GetSizeStatsFunction();
 
   // AsyncExtensionFunction overrides.
   virtual bool RunImpl() OVERRIDE;
 
  private:
   // A callback method to handle the result of
   // GetLocalPathsOnFileThreadAndRunCallbackOnUIThread.
   void GetLocalPathsResponseOnUIThread(const SelectedFileInfoList& files);
 
-  void GetDriveAvailableSpaceCallback(gdata::DriveFileError error,
+  void GetDriveAvailableSpaceCallback(drive::DriveFileError error,
                                       int64 bytes_total,
                                       int64 bytes_used);
 
   void GetSizeStatsCallbackOnUIThread(size_t total_size_kb,
                                       size_t remaining_size_kb);
   void CallGetSizeStatsOnFileThread(const std::string& mount_path);
 };
 
 // Retrieves devices meta-data. Expects volume's device path as an argument.
 class GetVolumeMetadataFunction : public FileBrowserFunction {
@@ skipping 48 matching lines @@
  protected:
   virtual ~FileDialogStringsFunction() {}
 
   // SyncExtensionFunction overrides.
   virtual bool RunImpl() OVERRIDE;
 };
 
 // Retrieve property information for multiple files, returning a list of the
 // same length as the input list of file URLs.  If a particular file has an
 // error, then return a dictionary with the key "error" set to the error number
-// (gdata::DriveFileError) for that entry in the returned list.
+// (drive::DriveFileError) for that entry in the returned list.
 class GetDriveFilePropertiesFunction : public FileBrowserFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("fileBrowserPrivate.getGDataFileProperties");
 
   GetDriveFilePropertiesFunction();
 
  protected:
   virtual ~GetDriveFilePropertiesFunction();
 
   void GetNextFileProperties();
   void CompleteGetFileProperties();
 
   // Virtual function that can be overridden to do operations on each virtual
   // file path and update its the properties.
   virtual void DoOperation(const FilePath& file_path,
                            base::DictionaryValue* properties,
-                           scoped_ptr<gdata::DriveEntryProto> entry_proto);
+                           scoped_ptr<drive::DriveEntryProto> entry_proto);
 
   void OnOperationComplete(const FilePath& file_path,
                            base::DictionaryValue* properties,
-                           gdata::DriveFileError error,
-                           scoped_ptr<gdata::DriveEntryProto> entry_proto);
+                           drive::DriveFileError error,
+                           scoped_ptr<drive::DriveEntryProto> entry_proto);
 
   // AsyncExtensionFunction overrides.
   virtual bool RunImpl() OVERRIDE;
 
   // Builds list of file properies. Calls DoOperation for each file.
   void PrepareResults();
 
  private:
   void OnGetFileInfo(const FilePath& file_path,
                      base::DictionaryValue* property_dict,
-                     gdata::DriveFileError error,
-                     scoped_ptr<gdata::DriveEntryProto> entry_proto);
+                     drive::DriveFileError error,
+                     scoped_ptr<drive::DriveEntryProto> entry_proto);
 
   void CacheStateReceived(base::DictionaryValue* property_dict,
                           bool success,
-                          const gdata::DriveCacheEntry& cache_entry);
+                          const drive::DriveCacheEntry& cache_entry);
 
   size_t current_index_;
   base::ListValue* path_list_;
   scoped_ptr<base::ListValue> file_properties_;
 };
 
 // Pin/unpin multiple files in the cache, returning a list of file
 // properties with the updated cache state.  The returned array is the
 // same length as the input list of file URLs.  If a particular file
 // has an error, then return a dictionary with the key "error" set to
-// the error number (gdata::DriveFileError) for that entry in the
+// the error number (drive::DriveFileError) for that entry in the
 // returned list.
 class PinDriveFileFunction : public GetDriveFilePropertiesFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("fileBrowserPrivate.pinGDataFile");
 
   PinDriveFileFunction();
 
  protected:
   virtual ~PinDriveFileFunction();
 
   // AsyncExtensionFunction overrides.
   virtual bool RunImpl() OVERRIDE;
 
  private:
   // Actually do the pinning/unpinning of each file.
   virtual void DoOperation(
       const FilePath& file_path,
       base::DictionaryValue* properties,
-      scoped_ptr<gdata::DriveEntryProto> entry_proto) OVERRIDE;
+      scoped_ptr<drive::DriveEntryProto> entry_proto) OVERRIDE;
 
   // Callback for SetPinState. Updates properties with error.
   void OnPinStateSet(const FilePath& path,
                      base::DictionaryValue* properties,
-                     scoped_ptr<gdata::DriveEntryProto> entry_proto,
-                     gdata::DriveFileError error,
+                     scoped_ptr<drive::DriveEntryProto> entry_proto,
+                     drive::DriveFileError error,
                      const std::string& resource_id,
                      const std::string& md5);
 
   // True for pin, false for unpin.
   bool set_pin_;
 };
 
 // Get file locations for the given list of file URLs. Returns a list of
 // location idenfitiers, like ['drive', 'local'], where 'drive' means the
 // file is on gdata, and 'local' means the file is on the local drive.
@@ skipping 39 matching lines @@
   // A callback method to handle the result of
   // GetLocalPathsOnFileThreadAndRunCallbackOnUIThread.
   void GetLocalPathsResponseOnUIThread(const SelectedFileInfoList& files);
 
   // Gets the file on the top of the |remaining_drive_paths_| or sends the
   // response if the queue is empty.
   void GetFileOrSendResponse();
 
   // Called by DriveFileSystem::GetFile(). Pops the file from
   // |remaining_drive_paths_|, and calls GetFileOrSendResponse().
-  void OnFileReady(gdata::DriveFileError error,
+  void OnFileReady(drive::DriveFileError error,
                    const FilePath& local_path,
                    const std::string& unused_mime_type,
-                   gdata::DriveFileType file_type);
+                   drive::DriveFileType file_type);
 
   std::queue<FilePath> remaining_drive_paths_;
   ListValue* local_paths_;
 };
 
 // Implements the chrome.fileBrowserPrivate.executeTask method.
 class GetFileTransfersFunction : public AsyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("fileBrowserPrivate.getFileTransfers");
 
@@ skipping 37 matching lines @@
 
   // AsyncExtensionFunction overrides.
   virtual bool RunImpl() OVERRIDE;
 
  private:
   // Helper callback for handling response from
   // GetLocalPathsOnFileThreadAndRunCallbackOnUIThread()
   void GetLocalPathsResponseOnUIThread(const SelectedFileInfoList& files);
 
   // Helper callback for handling response from DriveFileSystem::TransferFile().
-  void OnTransferCompleted(gdata::DriveFileError error);
+  void OnTransferCompleted(drive::DriveFileError error);
 };
 
 // Read setting value.
 class GetDrivePreferencesFunction : public SyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("fileBrowserPrivate.getGDataPreferences");
 
  protected:
   virtual ~GetDrivePreferencesFunction() {}
 
@@ skipping 21 matching lines @@
   virtual ~SearchDriveFunction();
 
   virtual bool RunImpl() OVERRIDE;
 
  private:
   // Callback fo OpenFileSystem called from RunImpl.
   void OnFileSystemOpened(base::PlatformFileError result,
                           const std::string& file_system_name,
                           const GURL& file_system_url);
   // Callback for gdata::SearchAsync called after file system is opened.
-  void OnSearch(gdata::DriveFileError error,
+  void OnSearch(drive::DriveFileError error,
                 const GURL& next_feed,
-                scoped_ptr<std::vector<gdata::SearchResultInfo> > result_paths);
+                scoped_ptr<std::vector<drive::SearchResultInfo> > result_paths);
 
   // Query for which the search is being performed.
   std::string query_;
   std::string next_feed_;
   // Information about remote file system we will need to create file entries
   // to represent search results.
   std::string file_system_name_;
   GURL file_system_url_;
 };
 
@@ skipping 25 matching lines @@
   DECLARE_EXTENSION_FUNCTION_NAME(
       "fileBrowserPrivate.requestDirectoryRefresh");
 
  protected:
   virtual ~RequestDirectoryRefreshFunction() {}
 
   virtual bool RunImpl() OVERRIDE;
 };
 
 #endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_BROWSER_PRIVATE_API_H_