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

chrome/browser/chromeos/drive/drive_uploader.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_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 namespace {
 
 // Google Documents List API requires uploading in chunks of 512kB.
 const int64 kUploadChunkSize = 512 * 1024;
 
 // Maximum number of times we try to open a file before giving up.
 const int kMaxFileOpenTries = 5;
 
 }  // namespace
 
-namespace gdata {
+namespace drive {
 
 DriveUploader::DriveUploader(DriveServiceInterface* drive_service)
   : drive_service_(drive_service),
     next_upload_id_(0),
     ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 DriveUploader::~DriveUploader() {
   STLDeleteContainerPairSecondPointers(pending_uploads_.begin(),
                                        pending_uploads_.end());
@@ skipping 10 matching lines @@
     const UploadCompletionCallback& completion_callback,
     const UploaderReadyCallback& ready_callback) {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    DCHECK(!upload_location.is_empty());
    DCHECK(!drive_file_path.empty());
    DCHECK(!local_file_path.empty());
    DCHECK(!title.empty());
    DCHECK(!content_type.empty());
 
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
-  upload_file_info->upload_mode = UPLOAD_NEW_FILE;
+  upload_file_info->upload_mode = gdata::UPLOAD_NEW_FILE;
   upload_file_info->initial_upload_location = upload_location;
   upload_file_info->drive_path = drive_file_path;
   upload_file_info->file_path = local_file_path;
   upload_file_info->title = title;
   upload_file_info->content_type = content_type;
   upload_file_info->content_length = content_length;
   upload_file_info->file_size = file_size;
   upload_file_info->all_bytes_present = content_length == file_size;
   upload_file_info->completion_callback = completion_callback;
   upload_file_info->ready_callback = ready_callback;
@@ skipping 15 matching lines @@
     int64 file_size,
     const UploadCompletionCallback& completion_callback,
     const UploaderReadyCallback& ready_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!upload_location.is_empty());
   DCHECK(!drive_file_path.empty());
   DCHECK(!local_file_path.empty());
   DCHECK(!content_type.empty());
 
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
-  upload_file_info->upload_mode = UPLOAD_EXISTING_FILE;
+  upload_file_info->upload_mode = gdata::UPLOAD_EXISTING_FILE;
   upload_file_info->initial_upload_location = upload_location;
   upload_file_info->drive_path = drive_file_path;
   upload_file_info->file_path = local_file_path;
   upload_file_info->content_type = content_type;
   upload_file_info->content_length = content_length;
   upload_file_info->file_size = file_size;
   upload_file_info->all_bytes_present = content_length == file_size;
   upload_file_info->completion_callback = completion_callback;
   upload_file_info->ready_callback = ready_callback;
 
   // When uploading a new file, we should retry file open as the file may
   // not yet be ready. See comments in OpenCompletionCallback.
   // TODO(satorux): The retry should be done only when we are uploading
   // while downloading files from web sites (i.e. saving files to Drive).
   upload_file_info->should_retry_file_open = true;
   return StartUploadFile(upload_file_info.Pass());
 }
 
 int DriveUploader::StartUploadFile(
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
   DCHECK_EQ(upload_file_info->upload_id, -1);
-  DCHECK_NE(UPLOAD_INVALID, upload_file_info->upload_mode);
+  DCHECK_NE(gdata::UPLOAD_INVALID, upload_file_info->upload_mode);
 
   const int upload_id = next_upload_id_++;
   upload_file_info->upload_id = upload_id;
 
   // Add upload_file_info to our internal map and take ownership.
   pending_uploads_[upload_id] = upload_file_info.release();
   UploadFileInfo* info = GetUploadFileInfo(upload_id);
   DVLOG(1) << "Uploading file: " << info->DebugString();
 
   // Create a FileStream to make sure the file can be opened successfully.
@@ skipping 16 matching lines @@
     int64 file_size,
     const UploadCompletionCallback& completion_callback,
     const UploaderReadyCallback& ready_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!upload_location.is_empty());
   DCHECK(!drive_file_path.empty());
   DCHECK(!local_file_path.empty());
   DCHECK(!content_type.empty());
 
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
-  upload_file_info->upload_mode = UPLOAD_EXISTING_FILE;
+  upload_file_info->upload_mode = gdata::UPLOAD_EXISTING_FILE;
   upload_file_info->initial_upload_location = upload_location;
   upload_file_info->drive_path = drive_file_path;
   upload_file_info->file_path = local_file_path;
   upload_file_info->content_type = content_type;
   upload_file_info->content_length = file_size;
   upload_file_info->file_size = file_size;
   upload_file_info->all_bytes_present = true;
   upload_file_info->completion_callback = completion_callback;
   upload_file_info->ready_callback = ready_callback;
 
@@ skipping 121 matching lines @@
       return;
     }
   } else {
     // Open succeeded, initiate the upload.
     upload_file_info->should_retry_file_open = false;
     if (upload_file_info->initial_upload_location.is_empty()) {
       UploadFailed(upload_file_info, DRIVE_FILE_ERROR_ABORT);
       return;
     }
     drive_service_->InitiateUpload(
-        InitiateUploadParams(upload_file_info->upload_mode,
+        gdata::InitiateUploadParams(upload_file_info->upload_mode,
                              upload_file_info->title,
                              upload_file_info->content_type,
                              upload_file_info->content_length,
                              upload_file_info->initial_upload_location,
                              upload_file_info->drive_path),
         base::Bind(&DriveUploader::OnUploadLocationReceived,
                    weak_ptr_factory_.GetWeakPtr(),
                    upload_file_info->upload_id));
   }
   // The uploader gets ready after we complete opening the file, called
   // from the StartUploadFile method. We use PostTask on purpose, because
   // this callback is called by FileStream, and we may access FileStream
   // again from the |ready_callback| implementation. FileStream is not
   // reentrant.
   //
   // Note, that we call this callback if we opened the file, or if we
   // failed, but further retries are scheduled. The callback will not be
   // called if the upload has been aborted.
   if (open_type == FILE_OPEN_START_UPLOAD &&
       !upload_file_info->ready_callback.is_null()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(upload_file_info->ready_callback, upload_id));
   }
 }
 
 void DriveUploader::OnUploadLocationReceived(
     int upload_id,
-    GDataErrorCode code,
+    gdata::GDataErrorCode code,
     const GURL& upload_location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   DVLOG(1) << "Got upload location [" << upload_location.spec()
            << "] for [" << upload_file_info->title << "]";
 
-  if (code != HTTP_SUCCESS) {
+  if (code != gdata::HTTP_SUCCESS) {
     // TODO(achuith): Handle error codes from Google Docs server.
     UploadFailed(upload_file_info, DRIVE_FILE_ERROR_ABORT);
     return;
   }
 
   upload_file_info->upload_location = upload_location;
 
   // Start the upload from the beginning of the file.
   UploadNextChunk(upload_file_info);
 }
@@ skipping 80 matching lines @@
 
   ResumeUpload(upload_id);
 }
 
 void DriveUploader::ResumeUpload(int upload_id) {
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   drive_service_->ResumeUpload(
-      ResumeUploadParams(upload_file_info->upload_mode,
-                         upload_file_info->start_range,
-                         upload_file_info->end_range,
-                         upload_file_info->content_length,
-                         upload_file_info->content_type,
-                         upload_file_info->buf,
-                         upload_file_info->upload_location,
-                         upload_file_info->drive_path),
+      gdata::ResumeUploadParams(upload_file_info->upload_mode,
+                                upload_file_info->start_range,
+                                upload_file_info->end_range,
+                                upload_file_info->content_length,
+                                upload_file_info->content_type,
+                                upload_file_info->buf,
+                                upload_file_info->upload_location,
+                                upload_file_info->drive_path),
       base::Bind(&DriveUploader::OnResumeUploadResponseReceived,
                  weak_ptr_factory_.GetWeakPtr(),
                  upload_file_info->upload_id));
 }
 
 void DriveUploader::OnResumeUploadResponseReceived(
     int upload_id,
-    const ResumeUploadResponse& response,
-    scoped_ptr<DocumentEntry> entry) {
+    const gdata::ResumeUploadResponse& response,
+    scoped_ptr<gdata::DocumentEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
-  const UploadMode upload_mode = upload_file_info->upload_mode;
-  if ((upload_mode == UPLOAD_NEW_FILE && response.code == HTTP_CREATED) ||
-      (upload_mode == UPLOAD_EXISTING_FILE && response.code == HTTP_SUCCESS)) {
+  const gdata::UploadMode upload_mode = upload_file_info->upload_mode;
+  if ((upload_mode == gdata::UPLOAD_NEW_FILE &&
+       response.code == gdata::HTTP_CREATED) ||
+      (upload_mode == gdata::UPLOAD_EXISTING_FILE &&
+       response.code == gdata::HTTP_SUCCESS)) {
     DVLOG(1) << "Successfully created uploaded file=["
              << upload_file_info->title;
 
     // Done uploading.
     upload_file_info->entry = entry.Pass();
     if (!upload_file_info->completion_callback.is_null()) {
       upload_file_info->completion_callback.Run(
           DRIVE_FILE_OK,
           upload_file_info->drive_path,
           upload_file_info->file_path,
           upload_file_info->entry.Pass());
     }
 
     // This will delete |upload_file_info|.
     RemoveUpload(scoped_ptr<UploadFileInfo>(upload_file_info));
     return;
   }
 
   // If code is 308 (RESUME_INCOMPLETE) and range_received is what has been
   // previously uploaded (i.e. = upload_file_info->end_range), proceed to
   // upload the next chunk.
-  if (response.code != HTTP_RESUME_INCOMPLETE ||
+  if (response.code != gdata::HTTP_RESUME_INCOMPLETE ||
       response.start_range_received != 0 ||
       response.end_range_received != upload_file_info->end_range) {
     // TODO(achuith): Handle error cases, e.g.
     // - when previously uploaded data wasn't received by Google Docs server,
     //   i.e. when end_range_received < upload_file_info->end_range
     LOG(ERROR) << "UploadNextChunk http code=" << response.code
                << ", start_range_received=" << response.start_range_received
                << ", end_range_received=" << response.end_range_received
                << ", expected end range=" << upload_file_info->end_range;
     UploadFailed(
         upload_file_info,
-        response.code == HTTP_FORBIDDEN ?
+        response.code == gdata::HTTP_FORBIDDEN ?
             DRIVE_FILE_ERROR_NO_SPACE : DRIVE_FILE_ERROR_ABORT);
     return;
   }
 
   DVLOG(1) << "Received range " << response.start_range_received
            << "-" << response.end_range_received
            << " for [" << upload_file_info->title << "]";
 
   // Continue uploading.
   UploadNextChunk(upload_file_info);
@@ skipping 18 matching lines @@
 
 void DriveUploader::RemoveUpload(scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   pending_uploads_.erase(upload_file_info->upload_id);
 }
 
 DriveUploader::UploadFileInfo::UploadFileInfo()
     : upload_id(-1),
       file_size(0),
       content_length(0),
-      upload_mode(UPLOAD_INVALID),
+      upload_mode(gdata::UPLOAD_INVALID),
       file_stream(NULL),
       buf_len(0),
       start_range(0),
       end_range(-1),
       all_bytes_present(false),
       upload_paused(false),
       should_retry_file_open(false),
       num_file_open_tries(0) {
 }
 
 DriveUploader::UploadFileInfo::~UploadFileInfo() { }
 
 int64 DriveUploader::UploadFileInfo::SizeRemaining() const {
   DCHECK(file_size > end_range);
   // Note that uploaded_bytes = end_range + 1;
   return file_size - end_range - 1;
 }
 
 std::string DriveUploader::UploadFileInfo::DebugString() const {
   return "title=[" + title +
          "], file_path=[" + file_path.AsUTF8Unsafe() +
          "], content_type=[" + content_type +
          "], content_length=[" + base::UintToString(content_length) +
          "], file_size=[" + base::UintToString(file_size) +
          "], drive_path=[" + drive_path.AsUTF8Unsafe() +
          "]";
 }
 
-}  // namespace gdata
+}  // namespace drive