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

chrome/browser/chromeos/extensions/file_browser_private_api.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/extensions/file_browser_private_api.h"
 
 #include <sys/statvfs.h>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 170 matching lines @@
 void AddDriveMountPoint(
     Profile* profile,
     const std::string& extension_id,
     content::RenderViewHost* render_view_host) {
   fileapi::ExternalFileSystemMountPointProvider* provider =
       BrowserContext::GetDefaultStoragePartition(profile)->
       GetFileSystemContext()->external_provider();
   if (!provider)
     return;
 
-  const FilePath mount_point = gdata::util::GetDriveMountPointPath();
+  const FilePath mount_point = drive::util::GetDriveMountPointPath();
   if (!render_view_host || !render_view_host->GetProcess())
     return;
 
   // Grant R/W permissions to drive 'folder'. File API layer still
   // expects this to be satisfied.
   GrantFilePermissionsToHost(render_view_host,
                              mount_point,
                              file_handler_util::GetReadWritePermissions());
 
   // Grant R/W permission for tmp and pinned cache folder.
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile);
   // |system_service| is NULL if incognito window / guest login.
   if (!system_service || !system_service->file_system())
     return;
-  gdata::DriveCache* cache = system_service->cache();
+  drive::DriveCache* cache = system_service->cache();
 
   // We check permissions for raw cache file paths only for read-only
   // operations (when fileEntry.file() is called), so read only permissions
   // should be sufficient for all cache paths. For the rest of supported
   // operations the file access check is done for drive/ paths.
   GrantFilePermissionsToHost(render_view_host,
                              cache->GetCacheDirectoryPath(
-                                 gdata::DriveCache::CACHE_TYPE_TMP),
+                                 drive::DriveCache::CACHE_TYPE_TMP),
                              file_handler_util::GetReadOnlyPermissions());
   GrantFilePermissionsToHost(
       render_view_host,
       cache->GetCacheDirectoryPath(
-          gdata::DriveCache::CACHE_TYPE_PERSISTENT),
+          drive::DriveCache::CACHE_TYPE_PERSISTENT),
       file_handler_util::GetReadOnlyPermissions());
 
   FilePath mount_point_virtual;
   if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
     provider->GrantFileAccessToExtension(extension_id, mount_point_virtual);
 }
 
 // Finds an icon in the list of icons. If unable to find an icon of the exact
 // size requested, returns one with the next larger size. If all icons are
 // smaller than the preferred size, we'll return the largest one available.
@@ skipping 283 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void RequestLocalFileSystemFunction::RespondSuccessOnUIThread(
     const std::string& name, const GURL& root_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Add drive mount point immediately when we kick of first instance of file
   // manager. The actual mount event will be sent to UI only when we perform
   // proper authentication.
-  if (gdata::DriveSystemService::IsDriveEnabled(profile_))
+  if (drive::DriveSystemService::IsDriveEnabled(profile_))
     AddDriveMountPoint(profile_, extension_id(), render_view_host());
   DictionaryValue* dict = new DictionaryValue();
   SetResult(dict);
   dict->SetString("name", name);
   dict->SetString("path", root_path.spec());
-  dict->SetInteger("error", gdata::DRIVE_FILE_OK);
+  dict->SetInteger("error", drive::DRIVE_FILE_OK);
   SendResponse(true);
 }
 
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
@@ skipping 82 matching lines @@
 bool RemoveFileWatchBrowserFunction::PerformFileWatchOperation(
     scoped_refptr<FileBrowserEventRouter> event_router,
     const FilePath& local_path, const FilePath& unused,
     const std::string& extension_id) {
   event_router->RemoveFileWatch(local_path, extension_id);
   return true;
 }
 
 // static
 void GetFileTasksFileBrowserFunction::IntersectAvailableDriveTasks(
-    gdata::DriveWebAppsRegistry* registry,
+    drive::DriveWebAppsRegistry* registry,
     const FileInfoList& file_info_list,
     WebAppInfoMap* app_info,
     std::set<std::string>* available_tasks) {
   for (FileInfoList::const_iterator file_iter = file_info_list.begin();
        file_iter != file_info_list.end(); ++file_iter) {
     if (file_iter->file_path.empty())
       continue;
-    ScopedVector<gdata::DriveWebAppInfo> info;
+    ScopedVector<drive::DriveWebAppInfo> info;
     registry->GetWebAppsForFile(file_iter->file_path,
                                 file_iter->mime_type, &info);
-    std::vector<gdata::DriveWebAppInfo*> info_ptrs;
+    std::vector<drive::DriveWebAppInfo*> info_ptrs;
     info.release(&info_ptrs);  // so they don't go away prematurely.
     std::set<std::string> tasks_for_this_file;
-    for (std::vector<gdata::DriveWebAppInfo*>::iterator
+    for (std::vector<drive::DriveWebAppInfo*>::iterator
          apps = info_ptrs.begin(); apps != info_ptrs.end(); ++apps) {
       std::pair<WebAppInfoMap::iterator, bool> insert_result =
           app_info->insert(std::make_pair((*apps)->app_id, *apps));
       // TODO(gspencer): For now, the action id is always "open-with", but we
       // could add any actions that the drive app supports.
       std::string task_id = file_handler_util::MakeTaskID(
           (*apps)->app_id, file_handler_util::kTaskDrive, "open-with");
       tasks_for_this_file.insert(task_id);
       // If we failed to insert a task_id because there was a duplicate, then we
       // must delete it (since we own it).
@@ skipping 37 matching lines @@
              iter != available_tasks.end(); ++iter) {
           VLOG(2) << "  " << *iter;
         }
       }
     }
   }
 }
 
 // static
 void GetFileTasksFileBrowserFunction::CreateDriveTasks(
-    gdata::DriveWebAppsRegistry* registry,
+    drive::DriveWebAppsRegistry* registry,
     const WebAppInfoMap& app_info,
     const std::set<std::string>& available_tasks,
     const std::set<std::string>& default_tasks,
     ListValue* result_list,
     bool* default_already_set) {
   *default_already_set = false;
   // OK, now we traverse the intersection of available applications for this
   // list of files, adding a task for each one that is found.
   for (std::set<std::string>::const_iterator app_iter = available_tasks.begin();
        app_iter != available_tasks.end(); ++app_iter) {
     std::string app_id;
     std::string task_type;
     bool result = file_handler_util::CrackTaskID(
         *app_iter, &app_id, &task_type, NULL);
     DCHECK(result) << "Unable to parse Drive task id: " << *app_iter;
     DCHECK_EQ(task_type, file_handler_util::kTaskDrive);
 
     WebAppInfoMap::const_iterator info_iter = app_info.find(app_id);
     DCHECK(info_iter != app_info.end());
-    gdata::DriveWebAppInfo* info = info_iter->second;
+    drive::DriveWebAppInfo* info = info_iter->second;
     DictionaryValue* task = new DictionaryValue;
 
     task->SetString("taskId", *app_iter);
     task->SetString("title", info->app_name);
 
     GURL best_icon = FindPreferredIcon(info->app_icons,
                                        kPreferredIconSize);
     if (!best_icon.is_empty()) {
       task->SetString("iconUrl", best_icon.spec());
     }
@@ skipping 16 matching lines @@
 // from drive. We'll know that they are drive apps because the extension id will
 // begin with kDriveTaskExtensionPrefix.
 bool GetFileTasksFileBrowserFunction::FindDriveAppTasks(
     const FileInfoList& file_info_list,
     ListValue* result_list,
     bool* default_already_set) {
 
   if (file_info_list.empty())
     return true;
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login. We return true
   // in this case because there might be other extension tasks, even if we don't
   // have any to add.
   if (!system_service || !system_service->webapps_registry())
     return true;
 
-  gdata::DriveWebAppsRegistry* registry = system_service->webapps_registry();
+  drive::DriveWebAppsRegistry* registry = system_service->webapps_registry();
 
   // Map of app_id to DriveWebAppInfo so we can look up the apps we've found
   // after taking the intersection of available apps.
-  std::map<std::string, gdata::DriveWebAppInfo*> app_info;
+  std::map<std::string, drive::DriveWebAppInfo*> app_info;
   // Set of application IDs. This will end up with the intersection of the
   // application IDs that apply to the paths in |file_paths|.
   std::set<std::string> available_tasks;
 
   IntersectAvailableDriveTasks(registry, file_info_list,
                                &app_info, &available_tasks);
   std::set<std::string> default_tasks;
   FindDefaultDriveTasks(file_info_list, available_tasks, &default_tasks);
   CreateDriveTasks(registry, app_info, available_tasks, default_tasks,
                    result_list, default_already_set);
@@ skipping 556 matching lines @@
   switch (mount_type) {
     case chromeos::MOUNT_TYPE_INVALID: {
       error_ = "Invalid mount type";
       SendResponse(false);
       break;
     }
     case chromeos::MOUNT_TYPE_GDATA: {
       const bool success = true;
       // Pass back the drive mount point path as source path.
       const std::string& drive_path =
-          gdata::util::GetDriveMountPointPathAsString();
+          drive::util::GetDriveMountPointPathAsString();
       SetResult(Value::CreateStringValue(drive_path));
       FileBrowserEventRouterFactory::GetForProfile(profile_)->
           MountDrive(base::Bind(&AddMountFunction::SendResponse,
                                 this,
                                 success));
       break;
     }
     default: {
       UrlList file_paths;
       file_paths.push_back(GURL(file_url));
@@ skipping 16 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!files.size()) {
     SendResponse(false);
     return;
   }
 
   const FilePath& source_path = files[0].local_path;
   const FilePath::StringType& display_name = files[0].display_name;
   // Check if the source path is under Drive cache directory.
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
-  gdata::DriveCache* cache = system_service ? system_service->cache() : NULL;
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveCache* cache = system_service ? system_service->cache() : NULL;
   if (cache && cache->IsUnderDriveCacheDirectory(source_path)) {
     cache->SetMountedStateOnUIThread(
         source_path,
         true,
         base::Bind(&AddMountFunction::OnMountedStateSet, this, mount_type_str,
                    display_name));
   } else {
     OnMountedStateSet(mount_type_str, display_name,
-                      gdata::DRIVE_FILE_OK, source_path);
+                      drive::DRIVE_FILE_OK, source_path);
   }
 }
 
 void AddMountFunction::OnMountedStateSet(const std::string& mount_type,
                                          const FilePath::StringType& file_name,
-                                         gdata::DriveFileError error,
+                                         drive::DriveFileError error,
                                          const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
   // Pass back the actual source path of the mount point.
   SetResult(Value::CreateStringValue(file_path.value()));
   SendResponse(true);
   // MountPath() takes a std::string.
   disk_mount_manager->MountPath(file_path.AsUTF8Unsafe(),
                                 FilePath(file_name).Extension(), file_name,
                                 DiskMountManager::MountTypeFromString(
@@ skipping 92 matching lines @@
 
 void GetSizeStatsFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
-  if (files[0].file_path == gdata::util::GetDriveMountPointPath()) {
-    gdata::DriveSystemService* system_service =
-        gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  if (files[0].file_path == drive::util::GetDriveMountPointPath()) {
+    drive::DriveSystemService* system_service =
+        drive::DriveSystemServiceFactory::GetForProfile(profile_);
 
-    gdata::DriveFileSystemInterface* file_system =
+    drive::DriveFileSystemInterface* file_system =
         system_service->file_system();
 
     file_system->GetAvailableSpace(
         base::Bind(&GetSizeStatsFunction::GetDriveAvailableSpaceCallback,
                    this));
 
   } else {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(
             &GetSizeStatsFunction::CallGetSizeStatsOnFileThread,
             this,
             files[0].file_path.value()));
   }
 }
 
 void GetSizeStatsFunction::GetDriveAvailableSpaceCallback(
-    gdata::DriveFileError error,
+    drive::DriveFileError error,
     int64 bytes_total,
     int64 bytes_used) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error == gdata::DRIVE_FILE_OK) {
+  if (error == drive::DRIVE_FILE_OK) {
     int64 bytes_remaining = bytes_total - bytes_used;
     GetSizeStatsCallbackOnUIThread(static_cast<size_t>(bytes_total/1024),
                                    static_cast<size_t>(bytes_remaining/1024));
   } else {
     // If stats couldn't be gotten for drive, result should be left undefined.
     SendResponse(true);
   }
 }
 
 void GetSizeStatsFunction::CallGetSizeStatsOnFileThread(
@@ skipping 462 matching lines @@
 
   SET_STRING(IDS_FILE_BROWSER, ALL_FILES_FILTER);
 #undef SET_STRING
 
   dict->SetBoolean("PDF_VIEW_ENABLED",
       file_manager_util::ShouldBeOpenedWithPdfPlugin(profile(), ".pdf"));
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(dict);
 
   dict->SetBoolean("ENABLE_GDATA",
-                   gdata::DriveSystemService::IsDriveEnabled(profile()));
+                   drive::DriveSystemService::IsDriveEnabled(profile()));
 
 #if defined(USE_ASH)
   dict->SetBoolean("ASH", true);
 #else
   dict->SetBoolean("ASH", false);
 #endif
 
   std::string board;
   const char kMachineInfoBoard[] = "CHROMEOS_RELEASE_BOARD";
   chromeos::system::StatisticsProvider* provider =
       chromeos::system::StatisticsProvider::GetInstance();
   if (!provider->GetMachineStatistic(kMachineInfoBoard, &board))
     board = "unknown";
   dict->SetString(kMachineInfoBoard, board);
 
   return true;
 }
 
 GetDriveFilePropertiesFunction::GetDriveFilePropertiesFunction() {
 }
 
 GetDriveFilePropertiesFunction::~GetDriveFilePropertiesFunction() {
 }
 
 void GetDriveFilePropertiesFunction::DoOperation(
     const FilePath& file_path,
     base::DictionaryValue* property_dict,
-    scoped_ptr<gdata::DriveEntryProto> entry_proto) {
+    scoped_ptr<drive::DriveEntryProto> entry_proto) {
   DCHECK(property_dict);
 
   // Nothing to do here so simply call OnOperationComplete().
   OnOperationComplete(file_path,
                       property_dict,
-                      gdata::DRIVE_FILE_OK,
+                      drive::DRIVE_FILE_OK,
                       entry_proto.Pass());
 }
 
 bool GetDriveFilePropertiesFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (args_->GetSize() != 1)
     return false;
 
   PrepareResults();
   return true;
@@ skipping 20 matching lines @@
   std::string file_str;
   path_list_->GetString(current_index_, &file_str);
   GURL file_url = GURL(file_str);
   FilePath file_path = GetVirtualPathFromURL(file_url);
 
   base::DictionaryValue* property_dict = new base::DictionaryValue;
   property_dict->SetString("fileUrl", file_url.spec());
   file_properties_->Append(property_dict);
 
   // Start getting the file info.
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   system_service->file_system()->GetEntryInfoByPath(
       file_path,
       base::Bind(&GetDriveFilePropertiesFunction::OnGetFileInfo,
                  this,
                  file_path,
                  property_dict));
 }
 
 void GetDriveFilePropertiesFunction::CompleteGetFileProperties() {
   current_index_++;
 
   // Could be called from callback. Let finish operation.
   MessageLoop::current()->PostTask(FROM_HERE,
       Bind(&GetDriveFilePropertiesFunction::GetNextFileProperties, this));
 }
 
 void GetDriveFilePropertiesFunction::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) {
   DCHECK(property_dict);
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = gdata::DRIVE_FILE_ERROR_NOT_FOUND;
+    error = drive::DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error == gdata::DRIVE_FILE_OK)
+  if (error == drive::DRIVE_FILE_OK)
     DoOperation(file_path, property_dict, entry_proto.Pass());
   else
     OnOperationComplete(file_path, property_dict, error, entry_proto.Pass());
 }
 
 void GetDriveFilePropertiesFunction::OnOperationComplete(
     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) {
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = gdata::DRIVE_FILE_ERROR_NOT_FOUND;
+    error = drive::DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error != gdata::DRIVE_FILE_OK) {
+  if (error != drive::DRIVE_FILE_OK) {
     property_dict->SetInteger("errorCode", error);
     CompleteGetFileProperties();
     return;
   }
   DCHECK(entry_proto.get());
 
-  const gdata::DriveFileSpecificInfo& file_specific_info =
+  const drive::DriveFileSpecificInfo& file_specific_info =
       entry_proto->file_specific_info();
   property_dict->SetString("thumbnailUrl", file_specific_info.thumbnail_url());
   if (!file_specific_info.alternate_url().empty())
     property_dict->SetString("editUrl", file_specific_info.alternate_url());
 
   if (!entry_proto->content_url().empty()) {
     property_dict->SetString("contentUrl", entry_proto->content_url());
   }
 
   property_dict->SetBoolean("isHosted",
                             file_specific_info.is_hosted_document());
 
   property_dict->SetString("contentMimeType",
                            file_specific_info.content_mime_type());
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
 
   // Get drive WebApps that can accept this file.
-  ScopedVector<gdata::DriveWebAppInfo> web_apps;
+  ScopedVector<drive::DriveWebAppInfo> web_apps;
   system_service->webapps_registry()->GetWebAppsForFile(
           file_path, file_specific_info.content_mime_type(), &web_apps);
   if (!web_apps.empty()) {
     std::string default_task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
         profile_,
         file_specific_info.content_mime_type(),
         file_path.Extension());
     std::string default_app_id;
     file_handler_util::CrackTaskID(
         default_task_id, &default_app_id, NULL, NULL);
 
     ListValue* apps = new ListValue();
     property_dict->Set("driveApps", apps);
-    for (ScopedVector<gdata::DriveWebAppInfo>::const_iterator it =
+    for (ScopedVector<drive::DriveWebAppInfo>::const_iterator it =
              web_apps.begin();
          it != web_apps.end(); ++it) {
-      const gdata::DriveWebAppInfo* webapp_info = *it;
+      const drive::DriveWebAppInfo* webapp_info = *it;
       DictionaryValue* app = new DictionaryValue();
       app->SetString("appId", webapp_info->app_id);
       app->SetString("appName", webapp_info->app_name);
       GURL app_icon = FindPreferredIcon(webapp_info->app_icons,
                                         kPreferredIconSize);
       if (!app_icon.is_empty())
         app->SetString("appIcon", app_icon.spec());
       GURL doc_icon = FindPreferredIcon(webapp_info->document_icons,
                                         kPreferredIconSize);
       if (!doc_icon.is_empty())
@@ skipping 18 matching lines @@
       entry_proto->resource_id(),
       file_specific_info.file_md5(),
       base::Bind(
           &GetDriveFilePropertiesFunction::CacheStateReceived,
           this, property_dict));
 }
 
 void GetDriveFilePropertiesFunction::CacheStateReceived(
     base::DictionaryValue* property_dict,
     bool /* success */,
-    const gdata::DriveCacheEntry& cache_entry) {
+    const drive::DriveCacheEntry& cache_entry) {
   // In case of an error (i.e. success is false), cache_entry.is_*() all
   // returns false.
   property_dict->SetBoolean("isPinned", cache_entry.is_pinned());
   property_dict->SetBoolean("isPresent", cache_entry.is_present());
   property_dict->SetBoolean("isDirty", cache_entry.is_dirty());
 
   CompleteGetFileProperties();
 }
 
 PinDriveFileFunction::PinDriveFileFunction() {
 }
 
 PinDriveFileFunction::~PinDriveFileFunction() {
 }
 
 bool PinDriveFileFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (args_->GetSize() != 2 || !args_->GetBoolean(1, &set_pin_))
     return false;
 
   PrepareResults();
 
   return true;
 }
 
 void PinDriveFileFunction::DoOperation(
     const FilePath& file_path,
     base::DictionaryValue* properties,
-    scoped_ptr<gdata::DriveEntryProto> entry_proto) {
+    scoped_ptr<drive::DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // This is subtle but we should take references of resource_id and md5
   // before |file_info| is passed to |callback| by base::Passed(). Otherwise,
   // file_info->whatever() crashes.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
-  const gdata::CacheOperationCallback callback =
+  const drive::CacheOperationCallback callback =
       base::Bind(&PinDriveFileFunction::OnPinStateSet,
                  this,
                  file_path,
                  properties,
                  base::Passed(&entry_proto));
 
   if (set_pin_)
     system_service->cache()->PinOnUIThread(resource_id, md5, callback);
   else
     system_service->cache()->UnpinOnUIThread(resource_id, md5, callback);
 }
 
 void PinDriveFileFunction::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 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   OnOperationComplete(path, properties, error, entry_proto.Pass());
 }
 
 GetFileLocationsFunction::GetFileLocationsFunction() {
 }
 
@@ skipping 20 matching lines @@
                  this));
   return true;
 }
 
 void GetFileLocationsFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ListValue* locations = new ListValue;
   for (size_t i = 0; i < files.size(); ++i) {
-    if (gdata::util::IsUnderDriveMountPoint(files[i].file_path)) {
+    if (drive::util::IsUnderDriveMountPoint(files[i].file_path)) {
       locations->Append(Value::CreateStringValue("drive"));
     } else {
       locations->Append(Value::CreateStringValue("local"));
     }
   }
 
   SetResult(locations);
   SendResponse(true);
 }
 
@@ skipping 23 matching lines @@
       base::Bind(&GetDriveFilesFunction::GetLocalPathsResponseOnUIThread,
                  this));
   return true;
 }
 
 void GetDriveFilesFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < files.size(); ++i) {
-    DCHECK(gdata::util::IsUnderDriveMountPoint(files[i].file_path));
-    FilePath drive_path = gdata::util::ExtractDrivePath(files[i].file_path);
+    DCHECK(drive::util::IsUnderDriveMountPoint(files[i].file_path));
+    FilePath drive_path = drive::util::ExtractDrivePath(files[i].file_path);
     remaining_drive_paths_.push(drive_path);
   }
 
   local_paths_ = new ListValue;
   GetFileOrSendResponse();
 }
 
 void GetDriveFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_drive_paths_.empty()) {
     SetResult(local_paths_);
     SendResponse(true);
     return;
   }
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   DCHECK(system_service);
 
   // Get the file on the top of the queue.
   FilePath drive_path = remaining_drive_paths_.front();
   system_service->file_system()->GetFileByPath(
       drive_path,
       base::Bind(&GetDriveFilesFunction::OnFileReady, this),
       gdata::GetContentCallback());
 }
 
 
 void GetDriveFilesFunction::OnFileReady(
-    gdata::DriveFileError error,
+    drive::DriveFileError error,
     const FilePath& local_path,
     const std::string& unused_mime_type,
-    gdata::DriveFileType file_type) {
+    drive::DriveFileType file_type) {
   FilePath drive_path = remaining_drive_paths_.front();
 
-  if (error == gdata::DRIVE_FILE_OK) {
+  if (error == drive::DRIVE_FILE_OK) {
     local_paths_->Append(Value::CreateStringValue(local_path.value()));
     DVLOG(1) << "Got " << drive_path.value() << " as " << local_path.value();
 
     // TODO(benchan): If the file is a hosted document, a temporary JSON file
     // is created to represent the document. The JSON file is not cached and
     // should be deleted after use. We need to somehow communicate with
     // file_manager.js to manage the lifetime of the temporary file.
     // See crosbug.com/28058.
   } else {
     local_paths_->Append(Value::CreateStringValue(""));
     DVLOG(1) << "Failed to get " << drive_path.value()
              << " with error code: " << error;
   }
 
   remaining_drive_paths_.pop();
 
   // Start getting the next file.
   GetFileOrSendResponse();
 }
 
 GetFileTransfersFunction::GetFileTransfersFunction() {}
 
 GetFileTransfersFunction::~GetFileTransfersFunction() {}
 
 ListValue* GetFileTransfersFunction::GetFileTransfersList() {
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service)
     return NULL;
 
   gdata::OperationProgressStatusList list =
       system_service->drive_service()->GetProgressStatusList();
   return file_manager_util::ProgressStatusVectorToListValue(
       profile_, source_url_.GetOrigin(), list);
 }
 
 bool GetFileTransfersFunction::RunImpl() {
@@ skipping 32 matching lines @@
   GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
       file_urls,
       base::Bind(&CancelFileTransfersFunction::GetLocalPathsResponseOnUIThread,
                  this));
   return true;
 }
 
 void CancelFileTransfersFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
   scoped_ptr<ListValue> responses(new ListValue());
   for (size_t i = 0; i < files.size(); ++i) {
-    DCHECK(gdata::util::IsUnderDriveMountPoint(files[i].file_path));
-    FilePath file_path = gdata::util::ExtractDrivePath(files[i].file_path);
+    DCHECK(drive::util::IsUnderDriveMountPoint(files[i].file_path));
+    FilePath file_path = drive::util::ExtractDrivePath(files[i].file_path);
     scoped_ptr<DictionaryValue> result(new DictionaryValue());
     result->SetBoolean(
         "canceled",
         system_service->drive_service()->CancelForFilePath(file_path));
     GURL file_url;
     if (file_manager_util::ConvertFileToFileSystemUrl(profile_,
-            gdata::util::GetSpecialRemoteRootPath().Append(file_path),
+            drive::util::GetSpecialRemoteRootPath().Append(file_path),
             source_url_.GetOrigin(),
             &file_url)) {
       result->SetString("fileUrl", file_url.spec());
     }
 
     responses->Append(result.release());
   }
   SetResult(responses.release());
   SendResponse(true);
 }
@@ skipping 22 matching lines @@
 }
 
 void TransferFileFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (files.size() != 2U) {
     SendResponse(false);
     return;
   }
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
   FilePath source_file = files[0].file_path;
   FilePath destination_file = files[1].file_path;
 
   bool source_file_under_drive =
-      gdata::util::IsUnderDriveMountPoint(source_file);
+      drive::util::IsUnderDriveMountPoint(source_file);
   bool destination_file_under_drive =
-      gdata::util::IsUnderDriveMountPoint(destination_file);
+      drive::util::IsUnderDriveMountPoint(destination_file);
 
   if (source_file_under_drive && !destination_file_under_drive) {
     // Transfer a file from gdata to local file system.
-    source_file = gdata::util::ExtractDrivePath(source_file);
+    source_file = drive::util::ExtractDrivePath(source_file);
     system_service->file_system()->TransferFileFromRemoteToLocal(
         source_file,
         destination_file,
         base::Bind(&TransferFileFunction::OnTransferCompleted, this));
   } else if (!source_file_under_drive && destination_file_under_drive) {
     // Transfer a file from local to Drive file system
-    destination_file = gdata::util::ExtractDrivePath(destination_file);
+    destination_file = drive::util::ExtractDrivePath(destination_file);
     system_service->file_system()->TransferFileFromLocalToRemote(
         source_file,
         destination_file,
         base::Bind(&TransferFileFunction::OnTransferCompleted, this));
   } else {
     // Local-to-local or Drive-to-Drive file transfers should be done via
     // FileEntry.copyTo in the File API and are thus not supported here.
     NOTREACHED();
     SendResponse(false);
   }
 }
 
-void TransferFileFunction::OnTransferCompleted(gdata::DriveFileError error) {
-  if (error == gdata::DRIVE_FILE_OK) {
+void TransferFileFunction::OnTransferCompleted(drive::DriveFileError error) {
+  if (error == drive::DRIVE_FILE_OK) {
     SendResponse(true);
   } else {
     error_ = base::StringPrintf("%d", static_cast<int>(
         fileapi::PlatformFileErrorToWebFileError(
-            gdata::DriveFileErrorToPlatformError(error))));
+            drive::DriveFileErrorToPlatformError(error))));
     SendResponse(false);
   }
 }
 
 // Read Drive-related preferences.
 bool GetDrivePreferencesFunction::RunImpl() {
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
 
   const PrefService* service = profile_->GetPrefs();
 
-  bool drive_enabled = gdata::DriveSystemService::IsDriveEnabled(profile_);
+  bool drive_enabled = drive::DriveSystemService::IsDriveEnabled(profile_);
 
   if (drive_enabled)
     AddDriveMountPoint(profile_, extension_id(), render_view_host());
 
   value->SetBoolean("driveEnabled", drive_enabled);
 
   value->SetBoolean("cellularDisabled",
                     service->GetBoolean(prefs::kDisableGDataOverCellular));
 
   value->SetBoolean("hostedFilesDisabled",
@@ skipping 48 matching lines @@
     const std::string& file_system_name,
     const GURL& file_system_url) {
   if (result != base::PLATFORM_FILE_OK) {
     SendResponse(false);
     return;
   }
 
   file_system_name_ = file_system_name;
   file_system_url_ = file_system_url;
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system()) {
     SendResponse(false);
     return;
   }
 
   system_service->file_system()->Search(
       query_, GURL(next_feed_),
       base::Bind(&SearchDriveFunction::OnSearch, this));
 }
 
 void SearchDriveFunction::OnSearch(
-    gdata::DriveFileError error,
+    drive::DriveFileError error,
     const GURL& next_feed,
-    scoped_ptr<std::vector<gdata::SearchResultInfo> > results) {
-  if (error != gdata::DRIVE_FILE_OK) {
+    scoped_ptr<std::vector<drive::SearchResultInfo> > results) {
+  if (error != drive::DRIVE_FILE_OK) {
     SendResponse(false);
     return;
   }
 
   DCHECK(results.get());
 
   base::ListValue* entries = new ListValue();
   // Convert Drive files to something File API stack can understand.
   for (size_t i = 0; i < results->size(); ++i) {
     DictionaryValue* entry = new DictionaryValue();
     entry->SetString("fileSystemName", file_system_name_);
     entry->SetString("fileSystemRoot", file_system_url_.spec());
     entry->SetString("fileFullPath", "/" + results->at(i).path.value());
     entry->SetBoolean("fileIsDirectory", results->at(i).is_directory);
 
     entries->Append(entry);
   }
 
   base::DictionaryValue* result = new DictionaryValue();
   result->Set("entries", entries);
   result->SetString("nextFeed", next_feed.spec());
 
   SetResult(result);
   SendResponse(true);
 }
 
 bool ClearDriveCacheFunction::RunImpl() {
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login.
   if (!system_service || !system_service->file_system())
     return false;
 
   // TODO(yoshiki): Receive a callback from JS-side and pass it to
   // ClearCacheAndRemountFileSystem(). http://crbug.com/140511
   system_service->ClearCacheAndRemountFileSystem(base::Callback<void(bool)>());
 
   SendResponse(true);
   return true;
@@ skipping 22 matching lines @@
   SetResult(value.release());
 
   return true;
 }
 
 bool RequestDirectoryRefreshFunction::RunImpl() {
   std::string file_url_as_string;
   if (!args_->GetString(0, &file_url_as_string))
     return false;
 
-  gdata::DriveSystemService* system_service =
-      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
+  drive::DriveSystemService* system_service =
+      drive::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }