Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_operations.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_operations.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
@@ skipping 143 matching lines @@
                                  net::EscapePath(
                                      directory_resource_id).c_str()));
 }
 
 }  // namespace
 
 namespace gdata {
 
 //============================ Structs ===========================
 
-ResumeUploadResponse::ResumeUploadResponse(GDataErrorCode code,
+ResumeUploadResponse::ResumeUploadResponse(DriveErrorCode code,
                                            int64 start_range_received,
                                            int64 end_range_received)
     : code(code),
       start_range_received(start_range_received),
       end_range_received(end_range_received) {
 }
 
 ResumeUploadResponse::~ResumeUploadResponse() {
 }
 
@@ skipping 149 matching lines @@
 }
 
 void DownloadFileOperation::OnURLFetchDownloadData(
     const URLFetcher* source,
     scoped_ptr<std::string> download_data) {
   if (!get_content_callback_.is_null())
     get_content_callback_.Run(HTTP_SUCCESS, download_data.Pass());
 }
 
 void DownloadFileOperation::ProcessURLFetchResults(const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode(source);
+  DriveErrorCode code = GetErrorCode(source);
 
   // Take over the ownership of the the downloaded temp file.
   FilePath temp_file;
   if (code == HTTP_SUCCESS &&
       !source->GetResponseAsFilePath(true,  // take_ownership
                                      &temp_file)) {
-    code = GDATA_FILE_ERROR;
+    code = DRIVE_FILE_ERROR;
   }
 
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, temp_file);
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
-void DownloadFileOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void DownloadFileOperation::RunCallbackOnPrematureFailure(DriveErrorCode code) {
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, document_url_, FilePath());
 }
 
 //=========================== DeleteDocumentOperation ==========================
 
 DeleteDocumentOperation::DeleteDocumentOperation(
     OperationRegistry* registry,
     const EntryActionCallback& callback,
     const GURL& document_url)
@@ skipping 198 matching lines @@
 
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "AuthorizeAppOperation data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 void AuthorizeAppsOperation::ParseResponse(
-    GDataErrorCode fetch_error_code,
+    DriveErrorCode fetch_error_code,
     const std::string& data) {
   // Parse entry XML.
   XmlReader xml_reader;
   scoped_ptr<DocumentEntry> entry;
   if (xml_reader.Load(data)) {
     while (xml_reader.Read()) {
       if (xml_reader.NodeName() == DocumentEntry::GetEntryNodeName()) {
         entry.reset(DocumentEntry::CreateFromXml(&xml_reader));
         break;
       }
@@ skipping 122 matching lines @@
 }
 
 InitiateUploadOperation::~InitiateUploadOperation() {}
 
 GURL InitiateUploadOperation::GetURL() const {
   return initiate_upload_url_;
 }
 
 void InitiateUploadOperation::ProcessURLFetchResults(
     const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode(source);
+  DriveErrorCode code = GetErrorCode(source);
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
   VLOG(1) << "Got response for [" << params_.title
           << "]: code=" << code
           << ", location=[" << upload_location << "]";
 
   if (!callback_.is_null())
     callback_.Run(code, GURL(upload_location));
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void InitiateUploadOperation::NotifySuccessToOperationRegistry() {
   NotifySuspend();
 }
 
 void InitiateUploadOperation::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveErrorCode code) {
   if (!callback_.is_null())
     callback_.Run(code, GURL());
 }
 
 URLFetcher::RequestType InitiateUploadOperation::GetRequestType() const {
   if (params_.upload_mode == UPLOAD_NEW_FILE)
     return URLFetcher::POST;
 
   DCHECK_EQ(UPLOAD_EXISTING_FILE, params_.upload_mode);
   return URLFetcher::PUT;
@@ skipping 57 matching lines @@
       last_chunk_completed_(false) {
 }
 
 ResumeUploadOperation::~ResumeUploadOperation() {}
 
 GURL ResumeUploadOperation::GetURL() const {
   return params_.upload_location;
 }
 
 void ResumeUploadOperation::ProcessURLFetchResults(const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode(source);
+  DriveErrorCode code = GetErrorCode(source);
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
   int64 start_range_received = -1;
   int64 end_range_received = -1;
   scoped_ptr<DocumentEntry> entry;
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
     std::string range_received;
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
     if (!range_received.empty()) {  // Parse the range header.
@@ skipping 54 matching lines @@
   NotifyResume();
 }
 
 void ResumeUploadOperation::NotifySuccessToOperationRegistry() {
   if (last_chunk_completed_)
     NotifyFinish(OperationRegistry::OPERATION_COMPLETED);
   else
     NotifySuspend();
 }
 
-void ResumeUploadOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void ResumeUploadOperation::RunCallbackOnPrematureFailure(DriveErrorCode code) {
   scoped_ptr<DocumentEntry> entry;
   if (!callback_.is_null())
     callback_.Run(ResumeUploadResponse(code, 0, 0), entry.Pass());
 }
 
 URLFetcher::RequestType ResumeUploadOperation::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
 std::vector<std::string> ResumeUploadOperation::GetExtraRequestHeaders() const {
@@ skipping 96 matching lines @@
 }
 
 GetContactPhotoOperation::~GetContactPhotoOperation() {}
 
 GURL GetContactPhotoOperation::GetURL() const {
   return photo_url_;
 }
 
 void GetContactPhotoOperation::ProcessURLFetchResults(
     const net::URLFetcher* source) {
-  GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
+  DriveErrorCode code = static_cast<DriveErrorCode>(source->GetResponseCode());
   scoped_ptr<std::string> data(new std::string);
   source->GetResponseAsString(data.get());
   callback_.Run(code, data.Pass());
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void GetContactPhotoOperation::RunCallbackOnPrematureFailure(
-    GDataErrorCode code) {
+    DriveErrorCode code) {
   scoped_ptr<std::string> data(new std::string);
   callback_.Run(code, data.Pass());
 }
 
 }  // namespace gdata