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

chrome/browser/chromeos/drive/drive_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/drive/drive_download_observer.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/string_number_conversions.h"
 #include "base/supports_user_data.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_service_interface.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
 #include "chrome/browser/download/download_completion_blocker.h"
 #include "chrome/browser/google_apis/gdata_util.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "net/base/net_util.h"
 
 using content::BrowserThread;
 using content::DownloadManager;
 using content::DownloadItem;
 
-namespace gdata {
+namespace drive {
 namespace {
 
 // Threshold file size after which we stream the file.
 const int64 kStreamingFileSize = 1 << 20;  // 1MB
 
 // Keys for base::SupportsUserData::Data.
 const char kUploadingKey[] = "Uploading";
 const char kGDataPathKey[] = "GDataPath";
 
 // User Data stored in DownloadItem for ongoing uploads.
 class UploadingUserData : public DownloadCompletionBlocker {
  public:
   explicit UploadingUserData(DriveUploader* uploader)
       : uploader_(uploader),
         upload_id_(-1),
         is_overwrite_(false) {
   }
   virtual ~UploadingUserData() {}
 
   DriveUploader* uploader() const { return uploader_; }
   void set_upload_id(int upload_id) { upload_id_ = upload_id; }
   int upload_id() const { return upload_id_; }
   void set_virtual_dir_path(const FilePath& path) { virtual_dir_path_ = path; }
   const FilePath& virtual_dir_path() const { return virtual_dir_path_; }
-  void set_entry(scoped_ptr<DocumentEntry> entry) { entry_ = entry.Pass(); }
-  scoped_ptr<DocumentEntry> entry_passed() { return entry_.Pass(); }
+  void set_entry(scoped_ptr<gdata::DocumentEntry> entry) {
+    entry_ = entry.Pass();
+  }
+  scoped_ptr<gdata::DocumentEntry> entry_passed() { return entry_.Pass(); }
   void set_overwrite(bool overwrite) { is_overwrite_ = overwrite; }
   bool is_overwrite() const { return is_overwrite_; }
   void set_resource_id(const std::string& resource_id) {
     resource_id_ = resource_id;
   }
   const std::string& resource_id() const { return resource_id_; }
   void set_md5(const std::string& md5) { md5_ = md5; }
   const std::string& md5() const { return md5_; }
 
  private:
   DriveUploader* uploader_;
   int upload_id_;
   FilePath virtual_dir_path_;
-  scoped_ptr<DocumentEntry> entry_;
+  scoped_ptr<gdata::DocumentEntry> entry_;
   bool is_overwrite_;
   std::string resource_id_;
   std::string md5_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadingUserData);
 };
 
 // User Data stored in DownloadItem for drive path.
 class DriveUserData : public base::SupportsUserData::Data {
  public:
@@ skipping 93 matching lines @@
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
 // Callback for DriveServiceInterface::Authenticate.
 void OnAuthenticate(Profile* profile,
                     const FilePath& drive_path,
                     const base::Closure& substitute_callback,
-                    GDataErrorCode error,
+                    gdata::GDataErrorCode error,
                     const std::string& token) {
   DVLOG(1) << "OnAuthenticate";
 
-  if (error == HTTP_SUCCESS) {
+  if (error == gdata::HTTP_SUCCESS) {
     const FilePath drive_dir_path =
         util::ExtractDrivePath(drive_path.DirName());
     // Ensure the directory exists. This also forces DriveFileSystem to
     // initialize DriveRootDirectory.
     GetSystemService(profile)->file_system()->GetEntryInfoByPath(
         drive_dir_path,
         base::Bind(&OnEntryFound, profile, drive_dir_path,
                    substitute_callback));
   } else {
     // TODO(achuith): Handle this.
@@ skipping 460 matching lines @@
 
   // Store upload id in the uploading data structure.
   upload_data->set_upload_id(upload_id);
 }
 
 void DriveDownloadObserver::OnUploadComplete(
     int32 download_id,
     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));
   DCHECK(document_entry.get());
 
   // Look up the DownloadItem for the |download_id|.
   DownloadMap::iterator iter = pending_downloads_.find(download_id);
   if (iter == pending_downloads_.end()) {
     DVLOG(1) << "Pending download not found" << download_id;
     return;
   }
   DVLOG(1) << "Completing upload for download ID " << download_id;
@@ skipping 13 matching lines @@
 
 void DriveDownloadObserver::MoveFileToDriveCache(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadingUserData* upload_data = GetUploadingUserData(download);
   if (!upload_data) {
     NOTREACHED();
     return;
   }
 
-  // Pass ownership of the DocumentEntry object.
-  scoped_ptr<DocumentEntry> entry = upload_data->entry_passed();
+  // Pass ownership of the gdata::DocumentEntry object.
+  scoped_ptr<gdata::DocumentEntry> entry = upload_data->entry_passed();
   if (!entry.get()) {
     NOTREACHED();
     return;
   }
 
   if (upload_data->is_overwrite()) {
     file_system_->UpdateEntryData(upload_data->resource_id(),
                                   upload_data->md5(),
                                   entry.Pass(),
                                   download->GetTargetFilePath(),
                                   base::Bind(&base::DoNothing));
   } else {
     // Move downloaded file to drive cache. Note that |content_file_path| should
     // use the final target path (download->GetTargetFilePath()) when the
     // download item has transitioned to the DownloadItem::COMPLETE state.
-    file_system_->AddUploadedFile(UPLOAD_NEW_FILE,
+    file_system_->AddUploadedFile(gdata::UPLOAD_NEW_FILE,
                                   upload_data->virtual_dir_path(),
                                   entry.Pass(),
                                   download->GetTargetFilePath(),
                                   DriveCache::FILE_OPERATION_MOVE,
                                   base::Bind(&base::DoNothing));
   }
 }
 
 DriveDownloadObserver::UploaderParams::UploaderParams()
     : file_size(0),
       content_length(-1),
       all_bytes_present(false) {
 }
 
 DriveDownloadObserver::UploaderParams::~UploaderParams() {
 }
 
 // Useful for printf debugging.
 std::string DriveDownloadObserver::UploaderParams::DebugString() const {
   return "title=[" + title +
          "], file_path=[" + file_path.value() +
          "], content_type=[" + content_type +
          "], content_length=[" + base::UintToString(content_length) +
          "], upload_location=[" + upload_location.possibly_invalid_spec() +
          "], drive_path=[" + drive_path.value() +
          "], all_bytes_present=[" + (all_bytes_present ?  "true" : "false") +
          "]";
 }
 
-}  // namespace gdata
+}  // namespace drive