Remove unnecessary gdata::, fix typos.

chrome/browser/chromeos/gdata/gdata_download_observer.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/gdata/gdata_download_observer.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/supports_user_data.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
@@ skipping 71 matching lines @@
   return static_cast<GDataUserData*>(
       download->GetUserData(&kGDataPathKey));
 }
 
 void RunSubstituteGDataDownloadCallback(
     const GDataDownloadObserver::SubstituteGDataDownloadPathCallback& callback,
     const FilePath* file_path) {
   callback.Run(*file_path);
 }
 
-gdata::GDataSystemService* GetSystemService(Profile* profile) {
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(
+GDataSystemService* GetSystemService(Profile* profile) {
+  GDataSystemService* system_service =
+      GDataSystemServiceFactory::GetForProfile(
         profile ? profile : ProfileManager::GetDefaultProfile());
   DCHECK(system_service);
   return system_service;
 }
 
 // Substitutes virtual gdata path for local temporary path.
 void SubstituteGDataDownloadPathInternal(Profile* profile,
     const GDataDownloadObserver::SubstituteGDataDownloadPathCallback&
         callback) {
   DVLOG(1) << "SubstituteGDataDownloadPathInternal";
 
   const FilePath gdata_tmp_download_dir = GetSystemService(profile)->cache()->
-      GetCacheDirectoryPath(gdata::GDataCache::CACHE_TYPE_TMP_DOWNLOADS);
+      GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP_DOWNLOADS);
 
   // Swap the gdata path with a local path. Local path must be created
   // on a blocking thread.
   FilePath* gdata_tmp_download_path(new FilePath());
-  BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
-      base::Bind(&gdata::GDataDownloadObserver::GetGDataTempDownloadPath,
+  BrowserThread::GetBlockingPool()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&GDataDownloadObserver::GetGDataTempDownloadPath,
                  gdata_tmp_download_dir,
                  gdata_tmp_download_path),
       base::Bind(&RunSubstituteGDataDownloadCallback,
                  callback,
                  base::Owned(gdata_tmp_download_path)));
 }
 
 // Callback for GDataFileSystem::CreateDirectory.
 void OnCreateDirectory(const base::Closure& substitute_callback,
                        GDataFileError error) {
   DVLOG(1) << "OnCreateDirectory " << error;
   if (error == GDATA_FILE_OK) {
     substitute_callback.Run();
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
 // Callback for GDataFileSystem::GetEntryInfoByPath.
 void OnEntryFound(Profile* profile,
     const FilePath& gdata_dir_path,
     const base::Closure& substitute_callback,
     GDataFileError error,
-    scoped_ptr<gdata::GDataEntryProto> entry_proto) {
+    scoped_ptr<GDataEntryProto> entry_proto) {
   if (error == GDATA_FILE_ERROR_NOT_FOUND) {
     // Destination gdata directory doesn't exist, so create it.
     const bool is_exclusive = false, is_recursive = true;
     GetSystemService(profile)->file_system()->CreateDirectory(
         gdata_dir_path, is_exclusive, is_recursive,
         base::Bind(&OnCreateDirectory, substitute_callback));
   } else if (error == GDATA_FILE_OK) {
     substitute_callback.Run();
   } else {
     // TODO(achuith): Handle this.
@@ skipping 56 matching lines @@
 }
 
 // static
 void GDataDownloadObserver::SubstituteGDataDownloadPath(Profile* profile,
     const FilePath& gdata_path, content::DownloadItem* download,
     const SubstituteGDataDownloadPathCallback& callback) {
   DVLOG(1) << "SubstituteGDataDownloadPath " << gdata_path.value();
 
   SetDownloadParams(gdata_path, download);
 
-  if (gdata::util::IsUnderGDataMountPoint(gdata_path)) {
+  if (util::IsUnderGDataMountPoint(gdata_path)) {
     // Can't access drive if we're not authenticated.
     // We set off a chain of callbacks as follows:
     // DocumentsService::Authenticate
     //   OnAuthenticate calls GDataFileSystem::GetEntryInfoByPath
     //     OnEntryFound calls GDataFileSystem::CreateDirectory (if necessary)
     //       OnCreateDirectory calls SubstituteGDataDownloadPathInternal
     GetSystemService(profile)->docs_service()->Authenticate(
         base::Bind(&OnAuthenticate, profile, gdata_path,
                    base::Bind(&SubstituteGDataDownloadPathInternal,
                               profile, callback)));
   } else {
     callback.Run(gdata_path);
   }
 }
 
 // static
 void GDataDownloadObserver::SetDownloadParams(const FilePath& gdata_path,
                                               DownloadItem* download) {
   if (!download)
     return;
 
-  if (gdata::util::IsUnderGDataMountPoint(gdata_path)) {
+  if (util::IsUnderGDataMountPoint(gdata_path)) {
     download->SetUserData(&kGDataPathKey,
                           new GDataUserData(gdata_path));
     download->SetDisplayName(gdata_path.BaseName());
     download->SetIsTemporary(true);
   } else if (IsGDataDownload(download)) {
     // This may have been previously set if the default download folder is
     // /drive, and the user has now changed the download target to a local
     // folder.
     download->SetUserData(&kGDataPathKey, NULL);
     download->SetDisplayName(gdata_path);
@@ skipping 327 matching lines @@
   // use the final target path when the download item is in COMPLETE state.
   file_system_->AddUploadedFile(UPLOAD_NEW_FILE,
                                 upload_data->virtual_dir_path(),
                                 entry.Pass(),
                                 download->GetTargetFilePath(),
                                 GDataCache::FILE_OPERATION_MOVE,
                                 base::Bind(&base::DoNothing));
 }
 
 }  // namespace gdata