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

chrome/browser/chromeos/drive/drive_system_service.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_system_service.h"
 
 #include "base/bind.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_api_service.h"
 #include "chrome/browser/chromeos/drive/drive_download_observer.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 namespace {
 
 // Used in test to setup system service.
 DriveServiceInterface* g_test_drive_service = NULL;
 const std::string* g_test_cache_root = NULL;
 
 // Map to collect profiles with Drive disabled.
 std::map<Profile*, bool>* g_drive_disabled_map = NULL;
 
 // Disables Drive for the specified profile. Used to disable Drive when
@@ skipping 71 matching lines @@
   file_system_.reset();
   webapps_registry_.reset();
   uploader_.reset();
   drive_service_.reset();
 }
 
 // static
 bool DriveSystemService::IsDriveEnabled(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!AuthService::CanAuthenticate(profile))
+  if (!gdata::AuthService::CanAuthenticate(profile))
     return false;
 
   // Disable gdata if preference is set.  This can happen with commandline flag
   // --disable-gdata or enterprise policy, or probably with user settings too
   // in the future.
   if (profile->GetPrefs()->GetBoolean(prefs::kDisableGData))
     return false;
 
   if (g_drive_disabled_map && g_drive_disabled_map->count(profile) > 0)
     return false;
@@ skipping 23 matching lines @@
   AddDriveMountPoint();
 
   if (!callback.is_null())
     callback.Run(error == DRIVE_FILE_OK);
 }
 
 void DriveSystemService::AddDriveMountPoint() {
   if (!IsDriveEnabled(profile_))
     return;
 
-  const FilePath mount_point = gdata::util::GetDriveMountPointPath();
+  const FilePath mount_point = util::GetDriveMountPointPath();
   fileapi::ExternalFileSystemMountPointProvider* provider =
       BrowserContext::GetDefaultStoragePartition(profile_)->
           GetFileSystemContext()->external_provider();
   if (provider && !provider->HasMountPoint(mount_point)) {
     provider->AddRemoteMountPoint(
         mount_point,
         new DriveFileSystemProxy(file_system_.get()));
   }
 
   file_system_->NotifyFileSystemMounted();
 }
 
 void DriveSystemService::RemoveDriveMountPoint() {
   file_system_->NotifyFileSystemToBeUnmounted();
   file_system_->StopUpdates();
 
-  const FilePath mount_point = gdata::util::GetDriveMountPointPath();
+  const FilePath mount_point = util::GetDriveMountPointPath();
   fileapi::ExternalFileSystemMountPointProvider* provider =
       BrowserContext::GetDefaultStoragePartition(profile_)->
           GetFileSystemContext()->external_provider();
   if (provider && provider->HasMountPoint(mount_point))
     provider->RemoveMountPoint(mount_point);
 }
 
 void DriveSystemService::OnCacheInitialized(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!success) {
     LOG(WARNING) << "Failed to initialize the cache. Disabling Drive";
     DisableDrive(profile_);
     // Change the download directory to the default value if the download
     // destination is set to under Drive mount point.
     //
     // TODO(satorux): This cannot be done in DisableDrive(), as there is a
     // dependency problem. We should move this code to DisableDrive() once
     // the dependency problem is solved. crbug.com/153962
     PrefService* pref_service = profile_->GetPrefs();
-    if (gdata::util::IsUnderDriveMountPoint(
+    if (util::IsUnderDriveMountPoint(
             pref_service->GetFilePath(prefs::kDownloadDefaultDirectory))) {
       pref_service->SetFilePath(prefs::kDownloadDefaultDirectory,
                                 download_util::GetDefaultDownloadDirectory());
     }
     return;
   }
 
   content::DownloadManager* download_manager =
     g_browser_process->download_status_updater() ?
         BrowserContext::GetDownloadManager(profile_) : NULL;
@@ skipping 51 matching lines @@
   g_test_cache_root = !cache_root.empty() ? new std::string(cache_root) : NULL;
 }
 
 ProfileKeyedService* DriveSystemServiceFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   DriveSystemService* service = new DriveSystemService(profile);
 
   DriveServiceInterface* drive_service = g_test_drive_service;
   g_test_drive_service = NULL;
   if (!drive_service) {
-    if (util::IsDriveV2ApiEnabled())
+    if (gdata::util::IsDriveV2ApiEnabled())
       drive_service = new DriveAPIService();
     else
       drive_service = new GDataWapiService();
   }
 
   FilePath cache_root =
       g_test_cache_root ? FilePath(*g_test_cache_root) :
                           DriveCache::GetCacheRootPath(profile);
   delete g_test_cache_root;
   g_test_cache_root = NULL;
 
   service->Initialize(drive_service, cache_root);
   return service;
 }
 
-}  // namespace gdata
+}  // namespace drive