Rename gdata_errorcode.h to drive_api_error_codes.h

chrome/browser/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/drive/drive_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "google_apis/drive/drive_api_parser.h"
 
 using google_apis::CancelCallback;
 using google_apis::FileResource;
-using google_apis::GDATA_CANCELLED;
-using google_apis::GDataErrorCode;
-using google_apis::GDATA_NO_SPACE;
+using google_apis::DRIVE_CANCELLED;

[mtomasz, 2015/01/29 06:18:02]

nit: ditto

+using google_apis::DriveApiErrorCode;
+using google_apis::DRIVE_NO_SPACE;
 using google_apis::HTTP_CONFLICT;
 using google_apis::HTTP_CREATED;
 using google_apis::HTTP_FORBIDDEN;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::ProgressCallback;
 using google_apis::UploadRangeResponse;
 
@@ skipping 193 matching lines @@
     bool get_file_size_result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!get_file_size_result) {
     UploadFailed(upload_file_info.Pass(), HTTP_NOT_FOUND);
     return;
   }
   DCHECK_GE(upload_file_info->content_length, 0);
 
   if (upload_file_info->cancelled) {
-    UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED);
+    UploadFailed(upload_file_info.Pass(), DRIVE_CANCELLED);
     return;
   }
   start_initiate_upload_callback.Run(upload_file_info.Pass());
 }
 
 void DriveUploader::CallUploadServiceAPINewFile(
     const std::string& parent_resource_id,
     const std::string& title,
     const UploadNewFileOptions& options,
     scoped_ptr<UploadFileInfo> upload_file_info) {
@@ skipping 36 matching lines @@
     info_ptr->cancel_callback = drive_service_->InitiateUploadExistingFile(
         info_ptr->content_type, info_ptr->content_length, resource_id, options,
         base::Bind(&DriveUploader::OnUploadLocationReceived,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&upload_file_info)));
   }
 }
 
 void DriveUploader::OnUploadLocationReceived(
     scoped_ptr<UploadFileInfo> upload_file_info,
-    GDataErrorCode code,
+    DriveApiErrorCode code,
     const GURL& upload_location) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Got upload location [" << upload_location.spec()
            << "] for [" << upload_file_info->file_path.value() << "]";
 
   if (code != HTTP_SUCCESS) {
     if (code == HTTP_PRECONDITION)
       code = HTTP_CONFLICT;  // ETag mismatch.
     UploadFailed(upload_file_info.Pass(), code);
@@ skipping 21 matching lines @@
 
 void DriveUploader::UploadNextChunk(
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(upload_file_info);
   DCHECK_GE(upload_file_info->next_start_position, 0);
   DCHECK_LE(upload_file_info->next_start_position,
             upload_file_info->content_length);
 
   if (upload_file_info->cancelled) {
-    UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED);
+    UploadFailed(upload_file_info.Pass(), DRIVE_CANCELLED);
     return;
   }
 
   // Limit the size of data uploaded per each request by kUploadChunkSize.
   const int64 end_position = std::min(
       upload_file_info->content_length,
       upload_file_info->next_start_position + kUploadChunkSize);
 
   UploadFileInfo* info_ptr = upload_file_info.get();
   info_ptr->cancel_callback = drive_service_->ResumeUpload(
@@ skipping 48 matching lines @@
   // (meaning that the data is uploaded from the beginning of the file),
   // proceed to upload the next chunk.
   if (response.code != HTTP_RESUME_INCOMPLETE ||
       response.start_position_received != 0) {
     DVLOG(1)
         << "UploadNextChunk http code=" << response.code
         << ", start_position_received=" << response.start_position_received
         << ", end_position_received=" << response.end_position_received;
     UploadFailed(
         upload_file_info.Pass(),
-        response.code == HTTP_FORBIDDEN ? GDATA_NO_SPACE : response.code);
+        response.code == HTTP_FORBIDDEN ? DRIVE_NO_SPACE : response.code);
     return;
   }
 
   DVLOG(1) << "Received range " << response.start_position_received
            << "-" << response.end_position_received
            << " for [" << upload_file_info->file_path.value() << "]";
 
   upload_file_info->next_start_position = response.end_position_received;
   UploadNextChunk(upload_file_info.Pass());
 }
 
 void DriveUploader::OnUploadProgress(const ProgressCallback& callback,
                                      int64 start_position,
                                      int64 total_size,
                                      int64 progress_of_chunk,
                                      int64 total_of_chunk) {
   if (!callback.is_null())
     callback.Run(start_position + progress_of_chunk, total_size);
 }
 
 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
-                                 GDataErrorCode error) {
+                                 DriveApiErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Upload failed " << upload_file_info->DebugString();
 
   if (upload_file_info->next_start_position < 0) {
     // Discard the upload location because no request could succeed with it.
     // Maybe it's obsolete.
     upload_file_info->upload_location = GURL();
   }
 
   upload_file_info->completion_callback.Run(
       error, upload_file_info->upload_location, scoped_ptr<FileResource>());
 }
 
 void DriveUploader::OnMultipartUploadComplete(
     scoped_ptr<UploadFileInfo> upload_file_info,
-    google_apis::GDataErrorCode error,
+    google_apis::DriveApiErrorCode error,
     scoped_ptr<FileResource> entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (error == HTTP_CREATED || error == HTTP_SUCCESS) {
     DVLOG(1) << "Successfully created uploaded file=["
              << upload_file_info->file_path.value() << "]";
     // Done uploading.
     upload_file_info->completion_callback.Run(
         HTTP_SUCCESS, upload_file_info->upload_location, entry.Pass());
   } else {
     DVLOG(1) << "Upload failed " << upload_file_info->DebugString();
     if (error == HTTP_PRECONDITION)
       error = HTTP_CONFLICT;  // ETag mismatch.
     upload_file_info->completion_callback.Run(
         error, upload_file_info->upload_location, scoped_ptr<FileResource>());
   }
 }
 
 }  // namespace drive