Rename gdata_errorcode.h to drive_api_error_codes.h

google_apis/drive/base_requests.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 "google_apis/drive/base_requests.h"
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
@@ skipping 273 matching lines @@
   if (!callback.is_null())
     callback.Run(result);
 }
 
 //============================ UrlFetchRequestBase ===========================
 
 UrlFetchRequestBase::UrlFetchRequestBase(RequestSender* sender)
     : re_authenticate_count_(0),
       response_writer_(NULL),
       sender_(sender),
-      error_code_(GDATA_OTHER_ERROR),
+      error_code_(DRIVE_OTHER_ERROR),
       weak_ptr_factory_(this) {
 }
 
 UrlFetchRequestBase::~UrlFetchRequestBase() {}
 
 void UrlFetchRequestBase::Start(const std::string& access_token,
                                 const std::string& custom_user_agent,
                                 const ReAuthenticateCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!access_token.empty());
   DCHECK(!callback.is_null());
   DCHECK(re_authenticate_callback_.is_null());
 
   re_authenticate_callback_ = callback;
 
   GURL url = GetURL();
   if (url.is_empty()) {
     // Error is found on generating the url. Send the error message to the
     // callback, and then return immediately without trying to connect
     // to the server.
-    RunCallbackOnPrematureFailure(GDATA_OTHER_ERROR);
+    RunCallbackOnPrematureFailure(DRIVE_OTHER_ERROR);
     return;
   }
   DVLOG(1) << "URL: " << url.spec();
 
   URLFetcher::RequestType request_type = GetRequestType();
   url_fetcher_.reset(URLFetcher::Create(url, request_type, this));
   url_fetcher_->SetRequestContext(sender_->url_request_context_getter());
   // Always set flags to neither send nor save cookies.
   url_fetcher_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES |
@@ skipping 81 matching lines @@
 }
 
 void UrlFetchRequestBase::GetOutputFilePath(
     base::FilePath* local_file_path,
     GetContentCallback* get_content_callback) {
 }
 
 void UrlFetchRequestBase::Cancel() {
   response_writer_ = NULL;
   url_fetcher_.reset(NULL);
-  RunCallbackOnPrematureFailure(GDATA_CANCELLED);
+  RunCallbackOnPrematureFailure(DRIVE_CANCELLED);
   sender_->RequestFinished(this);
 }
 
-GDataErrorCode UrlFetchRequestBase::GetErrorCode() {
+DriveApiErrorCode UrlFetchRequestBase::GetErrorCode() {
   return error_code_;
 }
 
 bool UrlFetchRequestBase::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 base::SequencedTaskRunner* UrlFetchRequestBase::blocking_task_runner() const {
   return sender_->blocking_task_runner();
 }
 
 void UrlFetchRequestBase::OnProcessURLFetchResultsComplete() {
   sender_->RequestFinished(this);
 }
 
 void UrlFetchRequestBase::OnURLFetchComplete(const URLFetcher* source) {
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   // Determine error code.
-  error_code_ = static_cast<GDataErrorCode>(source->GetResponseCode());
+  error_code_ = static_cast<DriveApiErrorCode>(source->GetResponseCode());
   if (!source->GetStatus().is_success()) {
     switch (source->GetStatus().error()) {
       case net::ERR_NETWORK_CHANGED:
-        error_code_ = GDATA_NO_CONNECTION;
+        error_code_ = DRIVE_NO_CONNECTION;
         break;
       default:
-        error_code_ = GDATA_OTHER_ERROR;
+        error_code_ = DRIVE_OTHER_ERROR;
     }
   }
 
   // The server may return detailed error status in JSON.
   // See https://developers.google.com/drive/handle-errors
   if (!IsSuccessfulResponseCode(error_code_)) {
     DVLOG(1) << response_writer_->data();
 
     const char kErrorKey[] = "error";
     const char kErrorErrorsKey[] = "errors";
@@ skipping 18 matching lines @@
       base::ListValue* errors = NULL;
       base::DictionaryValue* first_error = NULL;
       if (error->GetListWithoutPathExpansion(kErrorErrorsKey, &errors) &&
           errors->GetDictionary(0, &first_error)) {
         std::string reason;
         first_error->GetStringWithoutPathExpansion(kErrorReasonKey, &reason);
         if (reason == kErrorReasonRateLimitExceeded ||
             reason == kErrorReasonUserRateLimitExceeded)
           error_code_ = HTTP_SERVICE_UNAVAILABLE;
         if (reason == kErrorReasonQuotaExceeded)
-          error_code_ = GDATA_NO_SPACE;
+          error_code_ = DRIVE_NO_SPACE;
       }
     }
   }
 
   // Handle authentication failure.
   if (error_code_ == HTTP_UNAUTHORIZED) {
     if (++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerRequest) {
       // Reset re_authenticate_callback_ so Start() can be called again.
       ReAuthenticateCallback callback = re_authenticate_callback_;
       re_authenticate_callback_.Reset();
       callback.Run(this);
       return;
     }
 
     OnAuthFailed(error_code_);
     return;
   }
 
   // Overridden by each specialization
   ProcessURLFetchResults(source);
 }
 
-void UrlFetchRequestBase::OnAuthFailed(GDataErrorCode code) {
+void UrlFetchRequestBase::OnAuthFailed(DriveApiErrorCode code) {
   RunCallbackOnPrematureFailure(code);
   sender_->RequestFinished(this);
 }
 
 base::WeakPtr<AuthenticatedRequestInterface>
 UrlFetchRequestBase::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 //============================ EntryActionRequest ============================
 
 EntryActionRequest::EntryActionRequest(RequestSender* sender,
                                        const EntryActionCallback& callback)
     : UrlFetchRequestBase(sender),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 EntryActionRequest::~EntryActionRequest() {}
 
 void EntryActionRequest::ProcessURLFetchResults(const URLFetcher* source) {
   callback_.Run(GetErrorCode());
   OnProcessURLFetchResultsComplete();
 }
 
-void EntryActionRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void EntryActionRequest::RunCallbackOnPrematureFailure(DriveApiErrorCode code) {
   callback_.Run(code);
 }
 
 //========================= InitiateUploadRequestBase ========================
 
 InitiateUploadRequestBase::InitiateUploadRequestBase(
     RequestSender* sender,
     const InitiateUploadCallback& callback,
     const std::string& content_type,
     int64 content_length)
     : UrlFetchRequestBase(sender),
       callback_(callback),
       content_type_(content_type),
       content_length_(content_length) {
   DCHECK(!callback_.is_null());
   DCHECK(!content_type_.empty());
   DCHECK_GE(content_length_, 0);
 }
 
 InitiateUploadRequestBase::~InitiateUploadRequestBase() {}
 
 void InitiateUploadRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode();
+  DriveApiErrorCode code = GetErrorCode();
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
 
   callback_.Run(code, GURL(upload_location));
   OnProcessURLFetchResultsComplete();
 }
 
 void InitiateUploadRequestBase::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveApiErrorCode code) {
   callback_.Run(code, GURL());
 }
 
 std::vector<std::string>
 InitiateUploadRequestBase::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
   headers.push_back(kUploadContentType + content_type_);
   headers.push_back(
       kUploadContentLength + base::Int64ToString(content_length_));
   return headers;
 }
 
 //============================ UploadRangeResponse =============================
 
 UploadRangeResponse::UploadRangeResponse()
     : code(HTTP_SUCCESS),
       start_position_received(0),
       end_position_received(0) {
 }
 
-UploadRangeResponse::UploadRangeResponse(GDataErrorCode code,
+UploadRangeResponse::UploadRangeResponse(DriveApiErrorCode code,
                                          int64 start_position_received,
                                          int64 end_position_received)
     : code(code),
       start_position_received(start_position_received),
       end_position_received(end_position_received) {
 }
 
 UploadRangeResponse::~UploadRangeResponse() {
 }
 
@@ skipping 13 matching lines @@
   // has to be appended not here but in InitiateUploadRequestBase::GetURL().
   return upload_url_;
 }
 
 URLFetcher::RequestType UploadRangeRequestBase::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
 void UploadRangeRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode();
+  DriveApiErrorCode code = GetErrorCode();
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
     // The Range header is appeared only if there is at least one received
     // byte. So, initialize the positions by 0 so that the [0,0) will be
     // returned via the |callback_| for empty data case.
     int64 start_position_received = 0;
     int64 end_position_received = 0;
     std::string range_received;
@@ skipping 30 matching lines @@
                                        weak_ptr_factory_.GetWeakPtr(),
                                        code));
   } else {
     // Failed to upload. Run callbacks to notify the error.
     OnRangeRequestComplete(
         UploadRangeResponse(code, -1, -1), scoped_ptr<base::Value>());
     OnProcessURLFetchResultsComplete();
   }
 }
 
-void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
+void UploadRangeRequestBase::OnDataParsed(DriveApiErrorCode code,
                                           scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   DCHECK(code == HTTP_CREATED || code == HTTP_SUCCESS);
 
   OnRangeRequestComplete(UploadRangeResponse(code, -1, -1), value.Pass());
   OnProcessURLFetchResultsComplete();
 }
 
 void UploadRangeRequestBase::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveApiErrorCode code) {
   OnRangeRequestComplete(
       UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
 }
 
 //========================== ResumeUploadRequestBase =========================
 
 ResumeUploadRequestBase::ResumeUploadRequestBase(
     RequestSender* sender,
     const GURL& upload_location,
     int64 start_position,
@@ skipping 133 matching lines @@
 }
 
 void MultipartUploadRequestBase::OnPrepareUploadContent(
     const std::string& access_token,
     const std::string& custom_user_agent,
     const ReAuthenticateCallback& callback,
     std::string* upload_content_type,
     std::string* upload_content_data,
     bool result) {
   if (!result) {
-    RunCallbackOnPrematureFailure(GDATA_FILE_ERROR);
+    RunCallbackOnPrematureFailure(DRIVE_FILE_ERROR);
     return;
   }
   upload_content_type_.swap(*upload_content_type);
   upload_content_data_.swap(*upload_content_data);
   UrlFetchRequestBase::Start(access_token, custom_user_agent, callback);
 }
 
 void MultipartUploadRequestBase::SetBoundaryForTesting(
     const std::string& boundary) {
   boundary_ = boundary;
 }
 
 bool MultipartUploadRequestBase::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content_data) {
   // TODO(hirono): Pass stream instead of actual data to reduce memory usage.
   upload_content_type->swap(upload_content_type_);
   upload_content_data->swap(upload_content_data_);
   return true;
 }
 
 void MultipartUploadRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
   // The upload is successfully done. Parse the response which should be
   // the entry's metadata.
-  const GDataErrorCode code = GetErrorCode();
+  const DriveApiErrorCode code = GetErrorCode();
   if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     ParseJsonOnBlockingPool(
         blocking_task_runner(), response_writer()->data(),
         base::Bind(&MultipartUploadRequestBase::OnDataParsed,
                    weak_ptr_factory_.GetWeakPtr(), code));
   } else {
     OnDataParsed(code, scoped_ptr<base::Value>());
   }
 }
 
 void MultipartUploadRequestBase::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveApiErrorCode code) {
   callback_.Run(code, scoped_ptr<FileResource>());
 }
 
 void MultipartUploadRequestBase::OnURLFetchUploadProgress(
     const net::URLFetcher* source,
     int64 current,
     int64 total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
-void MultipartUploadRequestBase::OnDataParsed(GDataErrorCode code,
+void MultipartUploadRequestBase::OnDataParsed(DriveApiErrorCode code,
                                               scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   if (value)
     callback_.Run(code, google_apis::FileResource::CreateFrom(*value));
   else
-    callback_.Run(GDATA_PARSE_ERROR, scoped_ptr<FileResource>());
+    callback_.Run(DRIVE_PARSE_ERROR, scoped_ptr<FileResource>());
   OnProcessURLFetchResultsComplete();
 }
 
 //============================ DownloadFileRequestBase =========================
 
 DownloadFileRequestBase::DownloadFileRequestBase(
     RequestSender* sender,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback,
@@ skipping 27 matching lines @@
 
 void DownloadFileRequestBase::OnURLFetchDownloadProgress(
     const URLFetcher* source,
     int64 current,
     int64 total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 void DownloadFileRequestBase::ProcessURLFetchResults(const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode();
+  DriveApiErrorCode code = GetErrorCode();
 
   // Take over the ownership of the the downloaded temp file.
   base::FilePath temp_file;
   if (code == HTTP_SUCCESS) {
     response_writer()->DisownFile();
     temp_file = output_file_path_;
   }
 
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveApiErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis