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

chrome/browser/chromeos/drive/drive_file_system.cc

 // 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.
 
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop_proxy.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
 
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 const char kEmptyFilePath[] = "/dev/null";
 
 // Drive update check interval (in seconds).
 #ifndef NDEBUG
 const int kDriveUpdateCheckIntervalInSec = 5;
@@ skipping 136 matching lines @@
 }
 
 // Checks if a local file at |local_file_path| is a JSON file referencing a
 // hosted document on blocking pool, and if so, gets the resource ID of the
 // document.
 void GetDocumentResourceIdOnBlockingPool(
     const FilePath& local_file_path,
     std::string* resource_id) {
   DCHECK(resource_id);
 
-  if (DocumentEntry::HasHostedDocumentExtension(local_file_path)) {
+  if (gdata::DocumentEntry::HasHostedDocumentExtension(local_file_path)) {
     std::string error;
     DictionaryValue* dict_value = NULL;
     JSONFileValueSerializer serializer(local_file_path);
     scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
     if (value.get() && value->GetAsDictionary(&dict_value))
       dict_value->GetString("resource_id", resource_id);
   }
 }
 
 // Creates a temporary JSON file representing a document with |edit_url|
@@ skipping 139 matching lines @@
 // DriveFileSystem::GetFileFromCacheParams struct implementation.
 struct DriveFileSystem::GetFileFromCacheParams {
   GetFileFromCacheParams(
       const FilePath& virtual_file_path,
       const FilePath& local_tmp_path,
       const GURL& content_url,
       const std::string& resource_id,
       const std::string& md5,
       const std::string& mime_type,
       const GetFileCallback& get_file_callback,
-      const GetContentCallback& get_content_callback)
+      const gdata::GetContentCallback& get_content_callback)
       : virtual_file_path(virtual_file_path),
         local_tmp_path(local_tmp_path),
         content_url(content_url),
         resource_id(resource_id),
         md5(md5),
         mime_type(mime_type),
         get_file_callback(get_file_callback),
         get_content_callback(get_content_callback) {
   }
 
   FilePath virtual_file_path;
   FilePath local_tmp_path;
   FilePath cache_file_path;
   GURL content_url;
   std::string resource_id;
   std::string md5;
   std::string mime_type;
   GetFileCallback get_file_callback;
-  GetContentCallback get_content_callback;
+  gdata::GetContentCallback get_content_callback;
 };
 
 // DriveFileSystem::StartFileUploadParams implementation.
 struct DriveFileSystem::StartFileUploadParams {
   StartFileUploadParams(const FilePath& in_local_file_path,
                         const FilePath& in_remote_file_path,
                         const FileOperationCallback& in_callback)
       : local_file_path(in_local_file_path),
         remote_file_path(in_remote_file_path),
         callback(in_callback) {}
 
   const FilePath local_file_path;
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
 // DriveFileSystem::AddUploadedFileParams implementation.
 struct DriveFileSystem::AddUploadedFileParams {
-  AddUploadedFileParams(UploadMode upload_mode,
+  AddUploadedFileParams(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)
   : upload_mode(upload_mode),
     directory_path(directory_path),
     doc_entry(doc_entry.Pass()),
     file_content_path(file_content_path),
     cache_operation(cache_operation),
     callback(callback) {
   }
 
-  UploadMode upload_mode;
+  gdata::UploadMode upload_mode;
   FilePath directory_path;
-  scoped_ptr<DocumentEntry> doc_entry;
+  scoped_ptr<gdata::DocumentEntry> doc_entry;
   FilePath file_content_path;
   DriveCache::FileOperationType cache_operation;
   base::Closure callback;
   std::string resource_id;
   std::string md5;
 };
 
 // DriveFileSystem::UpdateEntryParams implementation.
 struct DriveFileSystem::UpdateEntryParams {
   UpdateEntryParams(const std::string& resource_id,
@@ skipping 145 matching lines @@
     update_timer_.Stop();
 }
 
 void DriveFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::GetEntryInfoByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
-                 CreateRelayCallback(callback)));
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::GetEntryInfoByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
@@ skipping 59 matching lines @@
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GetFileByPath(remote_src_file_path,
       base::Bind(&DriveFileSystem::OnGetFileCompleteForTransferFile,
                  ui_weak_ptr_,
                  local_dest_file_path,
                  callback),
-      GetContentCallback());
+      gdata::GetContentCallback());
 }
 
 void DriveFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Make sure the destination directory exists.
@@ skipping 22 matching lines @@
   }
 
   DCHECK(entry_proto.get());
   if (!entry_proto->file_info().is_directory()) {
     // The parent of |remote_dest_file_path| is not a directory.
     callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   std::string* resource_id = new std::string;
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetDocumentResourceIdOnBlockingPool,
                  local_src_file_path,
                  resource_id),
       base::Bind(&DriveFileSystem::TransferFileForResourceId,
                  ui_weak_ptr_,
                  local_src_file_path,
                  remote_dest_file_path,
                  callback,
@@ skipping 29 matching lines @@
 void DriveFileSystem::TransferRegularFile(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError* error =
       new DriveFileError(DRIVE_FILE_OK);
   int64* file_size = new int64;
   std::string* content_type = new std::string;
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileInfoOnBlockingPool,
                  local_file_path,
                  error,
                  file_size,
                  content_type),
       base::Bind(&DriveFileSystem::StartFileUploadOnUIThread,
                  ui_weak_ptr_,
                  StartFileUploadParams(local_file_path,
@@ skipping 63 matching lines @@
                                       ui_weak_ptr_,
                                       params.callback),
                            UploaderReadyCallback());
 }
 
 void DriveFileSystem::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == DRIVE_FILE_OK && document_entry.get()) {
-    AddUploadedFile(UPLOAD_NEW_FILE,
+    AddUploadedFile(gdata::UPLOAD_NEW_FILE,
                     drive_path.DirName(),
                     document_entry.Pass(),
                     file_path,
                     DriveCache::FILE_OPERATION_COPY,
                     base::Bind(&OnAddUploadFileCompleted, callback, error));
   } else if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void DriveFileSystem::Copy(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CopyOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::CopyOnUIThread,

[satorux1, 2012/10/12 05:32:56]

fixed the indent, and elsewhere in the file.

                                ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::CopyOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryInfoPairByPaths(
       src_file_path,
@@ skipping 45 matching lines @@
   }
 
   // TODO(kochi): Reimplement this once the server API supports
   // copying of regular files directly on the server side. crbug.com/138273
   const FilePath& src_file_path = result->first.path;
   GetFileByPath(src_file_path,
                 base::Bind(&DriveFileSystem::OnGetFileCompleteForCopy,
                            ui_weak_ptr_,
                            dest_file_path,
                            callback),
-                GetContentCallback());
+                gdata::GetContentCallback());
 }
 
 void DriveFileSystem::OnGetFileCompleteForCopy(
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     DriveFileError error,
     const FilePath& local_file_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 22 matching lines @@
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // GetFileByPath downloads the file from Drive to a local cache, which is then
   // copied to the actual destination path on the local file system using
   // CopyLocalFileOnBlockingPool.
   DriveFileError* copy_file_error =
       new DriveFileError(DRIVE_FILE_OK);
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&CopyLocalFileOnBlockingPool,
                  local_file_path,
                  local_dest_file_path,
                  copy_file_error),
       base::Bind(&RunFileOperationCallbackHelper,
                  callback,
                  base::Owned(copy_file_error)));
 }
@@ skipping 13 matching lines @@
                  callback));
 }
 
 void DriveFileSystem::Move(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::MoveOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::MoveOnUIThread,
                                ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::MoveOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   move_operation_->Move(src_file_path, dest_file_path, callback);
 }
 
 void DriveFileSystem::MoveEntryFromRootDirectory(
     const FilePath& directory_path,
@@ skipping 57 matching lines @@
                             callback)));
 }
 
 void DriveFileSystem::Remove(const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::RemoveOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::RemoveOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                is_recursive,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::RemoveOnUIThread(
     const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scheduler_->Remove(file_path, is_recursive, callback);
 }
 
 void DriveFileSystem::CreateDirectory(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CreateDirectoryOnUIThread,
-                               ui_weak_ptr_,
-                               directory_path,
-                               is_exclusive,
-                               is_recursive,
-                               CreateRelayCallback(callback)));
+  gdata::RunTaskOnUIThread(
+      base::Bind(&DriveFileSystem::CreateDirectoryOnUIThread,
+                 ui_weak_ptr_,
+                 directory_path,
+                 is_exclusive,
+                 is_recursive,
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::CreateDirectoryOnUIThread(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 56 matching lines @@
                      callback)));
 }
 
 void DriveFileSystem::CreateFile(const FilePath& file_path,
                                  bool is_exclusive,
                                  const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CreateFileOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::CreateFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                is_exclusive,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::CreateFileOnUIThread(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // First, checks the existence of a file at |file_path|.
@@ skipping 41 matching lines @@
 
   // No entry found at |file_path|. Let's create a brand new file.
   // For now, it is implemented by uploading an empty file (/dev/null).
   // TODO(kinaba): http://crbug.com/135143. Implement in a nicer way.
   TransferRegularFile(FilePath(kEmptyFilePath), file_path, callback);
 }
 
 void DriveFileSystem::GetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetContentCallback& get_content_callback) {
+    const gdata::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!get_file_callback.is_null());
 
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::GetFileByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
-                 CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_content_callback)));
+                 gdata::CreateRelayCallback(get_file_callback),
+                 gdata::CreateRelayCallback(get_content_callback)));
 }
 
 void DriveFileSystem::GetFileByPathOnUIThread(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
-    const GetContentCallback& get_content_callback) {
+    const gdata::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&DriveFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
                  ui_weak_ptr_,
                  file_path,
-                 CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_content_callback)));
+                 gdata::CreateRelayCallback(get_file_callback),
+                 gdata::CreateRelayCallback(get_content_callback)));
 }
 
 void DriveFileSystem::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> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     get_file_callback.Run(error, FilePath(), std::string(), REGULAR_FILE);
     return;
   }
   DCHECK(entry_proto.get());
 
   GetResolvedFileByPath(file_path,
                         get_file_callback,
                         get_content_callback,
                         entry_proto.Pass());
 }
 
 void DriveFileSystem::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
   DCHECK(entry_proto.get());
 
   if (!entry_proto->has_file_specific_info()) {
     get_file_callback.Run(DRIVE_FILE_ERROR_NOT_FOUND,
                           FilePath(),
                           std::string(),
                           REGULAR_FILE);
     return;
   }
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
   if (entry_proto->file_specific_info().is_hosted_document()) {
     DriveFileError* error =
         new DriveFileError(DRIVE_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     DriveFileType* file_type = new DriveFileType(REGULAR_FILE);
-    util::PostBlockingPoolSequencedTaskAndReply(
+    gdata::util::PostBlockingPoolSequencedTaskAndReply(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
                    cache_->GetCacheDirectoryPath(
                        DriveCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(entry_proto->file_specific_info().alternate_url()),
                    entry_proto->resource_id(),
                    error,
                    temp_file_path,
                    mime_type,
@@ skipping 26 matching lines @@
               entry_proto->resource_id(),
               entry_proto->file_specific_info().file_md5(),
               entry_proto->file_specific_info().content_mime_type(),
               get_file_callback,
               get_content_callback)));
 }
 
 void DriveFileSystem::GetFileByResourceId(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
-    const GetContentCallback& get_content_callback) {
+    const gdata::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::GetFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
-                 CreateRelayCallback(get_file_callback),
-                 CreateRelayCallback(get_content_callback)));
+                 gdata::CreateRelayCallback(get_file_callback),
+                 gdata::CreateRelayCallback(get_content_callback)));
 }
 
 void DriveFileSystem::GetFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
-    const GetContentCallback& get_content_callback) {
+    const gdata::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
 
   resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&DriveFileSystem::GetFileByResourceIdAfterGetEntry,
                  ui_weak_ptr_,
                  get_file_callback,
                  get_content_callback));
 }
 
 void DriveFileSystem::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     get_file_callback.Run(DRIVE_FILE_ERROR_NOT_FOUND,
                           FilePath(),
                           std::string(),
@@ skipping 37 matching lines @@
   GetFileFromCacheParams params(in_params);
   params.cache_file_path = cache_file_path;
   drive_service_->GetDocumentEntry(
       params.resource_id,
       base::Bind(&DriveFileSystem::OnGetDocumentEntry,
                  ui_weak_ptr_,
                  params));
 }
 
 void DriveFileSystem::OnGetDocumentEntry(const GetFileFromCacheParams& params,
-                                         GDataErrorCode status,
+                                         gdata::GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.get_file_callback.is_null());
 
   const DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     params.get_file_callback.Run(error,
                                  params.cache_file_path,
                                  params.mime_type,
                                  REGULAR_FILE);
     return;
   }
 
-  scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
+  scoped_ptr<gdata::DocumentEntry> doc_entry(
+      gdata::DocumentEntry::ExtractAndParse(*data));
   GURL content_url = doc_entry->content_url();
   int64 file_size = doc_entry->file_size();
 
   DCHECK(!content_url.is_empty());
   DCHECK_EQ(params.resource_id, doc_entry->resource_id());
   resource_metadata_->RefreshFile(
       doc_entry.Pass(),
       base::Bind(&DriveFileSystem::CheckForSpaceBeforeDownload,
                  ui_weak_ptr_,
                  params,
@@ skipping 13 matching lines @@
 
   if (error != DRIVE_FILE_OK) {
     params.get_file_callback.Run(error,
                                  params.cache_file_path,
                                  params.mime_type,
                                  REGULAR_FILE);
     return;
   }
 
   bool* has_enough_space = new bool(false);
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
       base::Bind(&DriveFileSystem::StartDownloadFileIfEnoughSpace,
                  ui_weak_ptr_,
                  params,
                  content_url,
@@ skipping 28 matching lines @@
                  params),
       params.get_content_callback);
 }
 
 void DriveFileSystem::GetEntryInfoByPath(const FilePath& file_path,
                                          const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::GetEntryInfoByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
-                 CreateRelayCallback(callback)));
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::GetEntryInfoByPathOnUIThread(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   LoadFeedIfNeeded(
       base::Bind(&DriveFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad,
@@ skipping 37 matching lines @@
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void DriveFileSystem::ReadDirectoryByPath(
     const FilePath& directory_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::ReadDirectoryByPathOnUIThread,
                  ui_weak_ptr_,
                  directory_path,
-                 CreateRelayCallback(callback)));
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::ReadDirectoryByPathOnUIThread(
     const FilePath& directory_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   LoadFeedIfNeeded(
       base::Bind(&DriveFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad,
@@ skipping 37 matching lines @@
     return;
   }
   DCHECK(entries.get());  // This is valid for emptry directories too.
 
   callback.Run(DRIVE_FILE_OK, hide_hosted_docs_, entries.Pass());
 }
 
 void DriveFileSystem::RequestDirectoryRefresh(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::RequestDirectoryRefreshOnUIThread,
                  ui_weak_ptr_,
                  directory_path));
 }
 
 void DriveFileSystem::RequestDirectoryRefreshOnUIThread(
     const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
@@ skipping 61 matching lines @@
                  FileOperationCallback()));
 }
 
 void DriveFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(
+  gdata::RunTaskOnUIThread(
       base::Bind(&DriveFileSystem::UpdateFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
-                 CreateRelayCallback(callback)));
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::UpdateFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // TODO(satorux): GetEntryInfoByResourceId() is called twice for
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
@@ skipping 46 matching lines @@
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // Gets the size of the cache file. Since the file is locally modified, the
   // file size information stored in DriveEntry is not correct.
   DriveFileError* get_size_error = new DriveFileError(DRIVE_FILE_ERROR_FAILED);
   int64* file_size = new int64(-1);
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileSizeOnBlockingPool,
                  cache_file_path,
                  get_size_error,
                  file_size),
       base::Bind(&DriveFileSystem::OnGetFileSizeCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback,
                  drive_file_path,
@@ skipping 31 matching lines @@
                  ui_weak_ptr_,
                  callback),
       UploaderReadyCallback());
 }
 
 void DriveFileSystem::OnUpdatedFileUploaded(
     const FileOperationCallback& callback,
     DriveFileError error,
     const FilePath& drive_path,
     const FilePath& file_path,
-    scoped_ptr<DocumentEntry> document_entry) {
+    scoped_ptr<gdata::DocumentEntry> document_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
-  AddUploadedFile(UPLOAD_EXISTING_FILE,
+  AddUploadedFile(gdata::UPLOAD_EXISTING_FILE,
                   drive_path.DirName(),
                   document_entry.Pass(),
                   file_path,
                   DriveCache::FILE_OPERATION_MOVE,
                   base::Bind(&OnAddUploadFileCompleted, callback, error));
 }
 
 void DriveFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::GetAvailableSpaceOnUIThread,
-                               ui_weak_ptr_,
-                               CreateRelayCallback(callback)));
+  gdata::RunTaskOnUIThread(
+      base::Bind(&DriveFileSystem::GetAvailableSpaceOnUIThread,
+                 ui_weak_ptr_,
+                 gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::GetAvailableSpaceOnUIThread(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   drive_service_->GetAccountMetadata(
       gdata::util::IsDriveV2ApiEnabled() ?
       base::Bind(&DriveFileSystem::OnGetAboutResource,
                  ui_weak_ptr_,
                  callback) :
       base::Bind(&DriveFileSystem::OnGetAvailableSpace,
                  ui_weak_ptr_,
                  callback));
 }
 
 void DriveFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
-  scoped_ptr<AccountMetadataFeed> feed;
+  scoped_ptr<gdata::AccountMetadataFeed> feed;
   if (data.get())
-    feed = AccountMetadataFeed::CreateFrom(*data);
+    feed = gdata::AccountMetadataFeed::CreateFrom(*data);
   if (!feed.get()) {
     callback.Run(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(DRIVE_FILE_OK,
                feed->quota_bytes_total(),
                feed->quota_bytes_used());
 }
 
 void DriveFileSystem::OnGetAboutResource(
     const GetAvailableSpaceCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> resource_json) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
-  scoped_ptr<AboutResource> about;
+  scoped_ptr<gdata::AboutResource> about;
   if (resource_json.get())
-    about = AboutResource::CreateFrom(*resource_json);
+    about = gdata::AboutResource::CreateFrom(*resource_json);
 
   if (!about.get()) {
     callback.Run(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(DRIVE_FILE_OK,
                about->quota_bytes_total(),
                about->quota_bytes_used());
 }
 
 void DriveFileSystem::AddNewDirectory(
     const CreateDirectoryParams& params,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     params.callback.Run(error);
     return;
   }
 
   resource_metadata_->AddEntryToDirectory(
       params.created_directory_path.DirName(),
-      scoped_ptr<DocumentEntry>(DocumentEntry::ExtractAndParse(*data)),
+      scoped_ptr<gdata::DocumentEntry>(
+          gdata::DocumentEntry::ExtractAndParse(*data)),
       base::Bind(&DriveFileSystem::ContinueCreateDirectory,
                  ui_weak_ptr_,
                  params));
 }
 
 void DriveFileSystem::ContinueCreateDirectory(
     const CreateDirectoryParams& params,
     DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 33 matching lines @@
     return;
   }
 
   // The search results will be returned using virtual directory.
   // The directory is not really part of the file system, so it has no parent or
   // root.
   std::vector<SearchResultInfo>* results(new std::vector<SearchResultInfo>());
   scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
 
   DCHECK_EQ(1u, params->feed_list.size());
-  DocumentFeed* feed = params->feed_list[0];
+  gdata::DocumentFeed* feed = params->feed_list[0];
 
   // TODO(tbarzic): Limit total number of returned results for the query.
   GURL next_feed;
   feed->GetNextFeedURL(&next_feed);
 
   const base::Closure callback = base::Bind(
       search_callback, DRIVE_FILE_OK, next_feed, base::Passed(&result_vec));
 
-  std::vector<DocumentEntry*> entries;
+  std::vector<gdata::DocumentEntry*> entries;
   feed->ReleaseEntries(&entries);
   if (entries.empty()) {
     callback.Run();
     return;
   }
 
   DVLOG(1) << "OnSearch number of entries=" << entries.size();
   // Go through all entries generated by the feed and add them to the search
   // result directory.
   for (size_t i = 0; i < entries.size(); ++i) {
     // Run the callback if this is the last iteration of the loop.
     const bool should_run_callback = (i+1 == entries.size());
     resource_metadata_->RefreshFile(
-        scoped_ptr<DocumentEntry>(entries[i]),
+        scoped_ptr<gdata::DocumentEntry>(entries[i]),
         base::Bind(&DriveFileSystem::AddToSearchResults,
                    ui_weak_ptr_,
                    results,
                    should_run_callback ? callback : base::Closure()));
   }
 }
 
 void DriveFileSystem::AddToSearchResults(
     std::vector<SearchResultInfo>* results,
     const base::Closure& callback,
@@ skipping 21 matching lines @@
     callback.Run();
 }
 
 void DriveFileSystem::Search(const std::string& search_query,
                              const GURL& next_feed,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::SearchAsyncOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::SearchAsyncOnUIThread,
                                ui_weak_ptr_,
                                search_query,
                                next_feed,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
     const GURL& next_feed,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   feed_loader_->SearchFromServer(
@@ skipping 26 matching lines @@
 
 void DriveFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->LoadFromCache(
       false,  // should_load_from_server.
       FileOperationCallback());
 }
 
 DriveFileError DriveFileSystem::UpdateFromFeedForTesting(
-    const ScopedVector<DocumentFeed>& feed_list,
+    const ScopedVector<gdata::DocumentFeed>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return feed_loader_->UpdateFromFeed(feed_list,
                                       start_changestamp,
                                       root_feed_changestamp);
 }
 
 void DriveFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by MoveEntryFromRootDirectory().
   resource_metadata_->AddEntryToDirectory(
       resource_metadata_->root()->GetFilePath(),
-      scoped_ptr<DocumentEntry>(DocumentEntry::ExtractAndParse(*data)),
+      scoped_ptr<gdata::DocumentEntry>(
+          gdata::DocumentEntry::ExtractAndParse(*data)),
       base::Bind(&DriveFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void DriveFileSystem::OnFileDownloaded(
     const GetFileFromCacheParams& params,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.get_file_callback.is_null());
 
   // If user cancels download of a pinned-but-not-fetched file, mark file as
   // unpinned so that we do not sync the file again.
-  if (status == GDATA_CANCELLED) {
+  if (status == gdata::GDATA_CANCELLED) {
     cache_->GetCacheEntryOnUIThread(
         params.resource_id,
         params.md5,
         base::Bind(&DriveFileSystem::UnpinIfPinned,
                    ui_weak_ptr_,
                    params.resource_id,
                    params.md5));
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  has_enough_space),
       base::Bind(&DriveFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
 }
 
 void DriveFileSystem::UnpinIfPinned(
     const std::string& resource_id,
     const std::string& md5,
     bool success,
     const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(hshi): http://crbug.com/127138 notify when file properties change.
   // This allows file manager to clear the "Available offline" checkbox.
   if (success && cache_entry.is_pinned())
     cache_->UnpinOnUIThread(resource_id, md5, CacheOperationCallback());
 }
 
 void DriveFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.get_file_callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
 
   // Make sure that downloaded file is properly stored in cache. We don't have
   // to wait for this operation to finish since the user can already use the
   // downloaded file.
   if (error == DRIVE_FILE_OK) {
     if (*has_enough_space) {
       cache_->StoreOnUIThread(
           params.resource_id,
           params.md5,
           downloaded_file_path,
           DriveCache::FILE_OPERATION_MOVE,
           base::Bind(&DriveFileSystem::OnDownloadStoredToCache,
                      ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
-      util::PostBlockingPoolSequencedTask(
+      gdata::util::PostBlockingPoolSequencedTask(
           FROM_HERE,
           blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
                      false /* recursive*/));
       error = DRIVE_FILE_ERROR_NO_SPACE;
     }
   }
 
   params.get_file_callback.Run(error,
                                downloaded_file_path,
                                params.mime_type,
                                REGULAR_FILE);
 }
 
 void DriveFileSystem::OnDownloadStoredToCache(DriveFileError error,
                                               const std::string& resource_id,
                                               const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Nothing much to do here for now.
 }
 
 void DriveFileSystem::MoveEntryToDirectory(
     const FilePath& file_path,
     const FilePath& directory_path,
     const FileMoveCallback& callback,
-    GDataErrorCode status,
+    gdata::GDataErrorCode status,
     const GURL& /* document_url */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   const DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, FilePath());
     return;
   }
 
@@ skipping 126 matching lines @@
     params->callback.Run(result);
   } else {
     // This parent exists, so recursively look at the next element.
     params->last_dir_content_url = GURL(entry_proto->content_url());
     params->index++;
     FindFirstMissingParentDirectoryInternal(params.Pass());
   }
 }
 
 void DriveFileSystem::AddUploadedFile(
-    UploadMode upload_mode,
+    gdata::UploadMode upload_mode,
     const FilePath& directory_path,
-    scoped_ptr<DocumentEntry> entry,
+    scoped_ptr<gdata::DocumentEntry> entry,
     const FilePath& file_content_path,
     DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // AddUploadedFile() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&DriveFileSystem::AddUploadedFileOnUIThread,
                  ui_weak_ptr_,
                  upload_mode,
                  directory_path,
                  base::Passed(&entry),
                  file_content_path,
                  cache_operation,
                  callback));
 }
 
 void DriveFileSystem::AddUploadedFileOnUIThread(
-    UploadMode upload_mode,
+    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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(doc_entry.get());
 
   const std::string& resource_id = doc_entry->resource_id();
   scoped_ptr<AddUploadedFileParams> params(
       new AddUploadedFileParams(upload_mode,
                                 directory_path,
                                 doc_entry.Pass(),
                                 file_content_path,
                                 cache_operation,
                                 callback));
 
   const FileMoveCallback file_move_callback =
       base::Bind(&DriveFileSystem::ContinueAddUploadedFile,
                  ui_weak_ptr_, base::Passed(&params));
 
-  if (upload_mode == UPLOAD_EXISTING_FILE) {
+  if (upload_mode == gdata::UPLOAD_EXISTING_FILE) {
     // Remove the existing entry.
     resource_metadata_->RemoveEntryFromParent(resource_id, file_move_callback);
   } else {
     file_move_callback.Run(DRIVE_FILE_OK, FilePath());
   }
 }
 
 void DriveFileSystem::ContinueAddUploadedFile(
     scoped_ptr<AddUploadedFileParams> params,
     DriveFileError error,
     const FilePath& /* file_path */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(DRIVE_FILE_OK, error);
   DCHECK(params->doc_entry.get());
 
   params->resource_id = params->doc_entry->resource_id();
   params->md5 = params->doc_entry->file_md5();
   DCHECK(!params->resource_id.empty());
   DCHECK(!params->md5.empty());
 
   // Get parameters before base::Passed() invalidates |params|.
   const FilePath& directory_path = params->directory_path;
-  scoped_ptr<DocumentEntry> doc_entry(params->doc_entry.Pass());
+  scoped_ptr<gdata::DocumentEntry> doc_entry(params->doc_entry.Pass());
 
   resource_metadata_->AddEntryToDirectory(
       directory_path,
       doc_entry.Pass(),
       base::Bind(&DriveFileSystem::AddUploadedFileToCache,
                  ui_weak_ptr_,
                  base::Passed(&params)));
 }
 
 void DriveFileSystem::AddUploadedFileToCache(
     scoped_ptr<AddUploadedFileParams> params,
     DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params->resource_id.empty());
   DCHECK(!params->md5.empty());
   DCHECK(!params->resource_id.empty());
   DCHECK(!params->callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     params->callback.Run();
     return;
   }
 
   OnDirectoryChanged(file_path.DirName());
 
-  if (params->upload_mode == UPLOAD_NEW_FILE) {
+  if (params->upload_mode == gdata::UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(params->resource_id,
                             params->md5,
                             params->file_content_path,
                             params->cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                        params->callback));
-  } else if (params->upload_mode == UPLOAD_EXISTING_FILE) {
+  } else if (params->upload_mode == gdata::UPLOAD_EXISTING_FILE) {
     // Clear the dirty bit if we have updated an existing file.
     cache_->ClearDirtyOnUIThread(params->resource_id,
                                  params->md5,
                                  base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                             params->callback));
   } else {
     NOTREACHED() << "Unexpected upload mode: " << params->upload_mode;
     // Shouldn't reach here, so the line below should not make much sense, but
     // since calling |callback| exactly once is our obligation, we'd better call
     // it for not to clutter further more.
     params->callback.Run();
   }
 }
 
 void DriveFileSystem::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // UpdateEntryData() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&DriveFileSystem::UpdateEntryDataOnUIThread,
                  ui_weak_ptr_,
                  UpdateEntryParams(resource_id,
                                    md5,
                                    file_content_path,
                                    callback),
                  base::Passed(&entry)));
 }
 
 void DriveFileSystem::UpdateEntryDataOnUIThread(
     const UpdateEntryParams& params,
-    scoped_ptr<DocumentEntry> entry) {
+    scoped_ptr<gdata::DocumentEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_metadata_->RefreshFile(
       entry.Pass(),
       base::Bind(&DriveFileSystem::UpdateCacheEntryOnUIThread,
                  ui_weak_ptr_,
                  params));
 }
 
 void DriveFileSystem::UpdateCacheEntryOnUIThread(
@@ skipping 54 matching lines @@
 
   pref_registrar_.reset(new PrefChangeRegistrar());
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void DriveFileSystem::OpenFile(const FilePath& file_path,
                                const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::OpenFileOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::OpenFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::OpenFileOnUIThread(const FilePath& file_path,
                                          const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the file is already opened, it cannot be opened again before closed.
   // This is for avoiding simultaneous modification to the file, and moreover
   // to avoid an inconsistent cache state (suppose an operation sequence like
   // Open->Open->modify->Close->modify->Close; the second modify may not be
@@ skipping 46 matching lines @@
   // Extract a pointer before we call Pass() so we can use it below.
   DriveEntryProto* entry_proto_ptr = entry_proto.get();
   GetResolvedFileByPath(
       file_path,
       base::Bind(&DriveFileSystem::OnGetFileCompleteForOpenFile,
                  ui_weak_ptr_,
                  callback,
                  GetFileCompleteForOpenParams(
                      entry_proto_ptr->resource_id(),
                      entry_proto_ptr->file_specific_info().file_md5())),
-      GetContentCallback(),
+      gdata::GetContentCallback(),
       entry_proto.Pass());
 }
 
 void DriveFileSystem::OnGetFileCompleteForOpenFile(
     const OpenFileCallback& callback,
     const GetFileCompleteForOpenParams& entry_proto,
     DriveFileError error,
     const FilePath& file_path,
     const std::string& mime_type,
     DriveFileType file_type) {
@@ skipping 41 matching lines @@
   if (!callback.is_null())
     callback.Run(result, cache_file_path);
 }
 
 void DriveFileSystem::CloseFile(const FilePath& file_path,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CloseFileOnUIThread,
+  gdata::RunTaskOnUIThread(base::Bind(&DriveFileSystem::CloseFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
-                               CreateRelayCallback(callback)));
+                               gdata::CreateRelayCallback(callback)));
 }
 
 void DriveFileSystem::CloseFileOnUIThread(
     const FilePath& file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (open_files_.find(file_path) == open_files_.end()) {
     // The file is not being opened.
@@ skipping 133 matching lines @@
 
   // When no dirty cache is found, use the original entry info as is.
   if (error != DRIVE_FILE_OK) {
     callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
-  util::PostBlockingPoolSequencedTaskAndReply(
+  gdata::util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&DriveFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
@@ skipping 13 matching lines @@
     callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
-}  // namespace gdata
+}  // namespace drive