google_apis: Clean up gdata_wapi_operations.h

chrome/browser/google_apis/gdata_wapi_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/google_apis/gdata_wapi_operations.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
@@ skipping 48 matching lines @@
 
 ResumeUploadResponse::~ResumeUploadResponse() {
 }
 
 InitiateUploadParams::InitiateUploadParams(
     UploadMode upload_mode,
     const std::string& title,
     const std::string& content_type,
     int64 content_length,
     const GURL& upload_location,
-    const FilePath& virtual_path)
+    const FilePath& drive_file_path)
     : upload_mode(upload_mode),
       title(title),
       content_type(content_type),
       content_length(content_length),
       upload_location(upload_location),
-      virtual_path(virtual_path) {
+      drive_file_path(drive_file_path) {
 }
 
 InitiateUploadParams::~InitiateUploadParams() {
 }
 
 ResumeUploadParams::ResumeUploadParams(
     UploadMode upload_mode,
     int64 start_range,
     int64 end_range,
     int64 content_length,
     const std::string& content_type,
     scoped_refptr<net::IOBuffer> buf,
     const GURL& upload_location,
-    const FilePath& virtual_path) : upload_mode(upload_mode),
+    const FilePath& drive_file_path) : upload_mode(upload_mode),
                                     start_range(start_range),
                                     end_range(end_range),
                                     content_length(content_length),
                                     content_type(content_type),
                                     buf(buf),
                                     upload_location(upload_location),
-                                    virtual_path(virtual_path) {
+                                    drive_file_path(drive_file_path) {
 }
 
 ResumeUploadParams::~ResumeUploadParams() {
 }
 
 //============================ GetDocumentsOperation ===========================
 
 GetDocumentsOperation::GetDocumentsOperation(
     OperationRegistry* registry,
     const GDataWapiUrlGenerator& url_generator,
-    const GURL& url,
+    const GURL& override_url,
     int start_changestamp,
     const std::string& search_string,
     bool shared_with_me,
     const std::string& directory_resource_id,
     const GetDataCallback& callback)
     : GetDataOperation(registry, callback),
       url_generator_(url_generator),
-      override_url_(url),
+      override_url_(override_url),
       start_changestamp_(start_changestamp),
       search_string_(search_string),
       shared_with_me_(shared_with_me),
       directory_resource_id_(directory_resource_id) {
 }
 
 GetDocumentsOperation::~GetDocumentsOperation() {}
 
 GURL GetDocumentsOperation::GetURL() const {
   return url_generator_.GenerateDocumentListUrl(override_url_,
@@ skipping 36 matching lines @@
 GURL GetAccountMetadataOperation::GetURL() const {
   return url_generator_.GenerateAccountMetadataUrl();
 }
 
 //============================ DownloadFileOperation ===========================
 
 DownloadFileOperation::DownloadFileOperation(
     OperationRegistry* registry,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
-    const GURL& document_url,
-    const FilePath& virtual_path,
+    const GURL& content_url,
+    const FilePath& drive_file_path,
     const FilePath& output_file_path)
     : UrlFetchOperationBase(registry,
                             OPERATION_DOWNLOAD,
-                            virtual_path),
+                            drive_file_path),
       download_action_callback_(download_action_callback),
       get_content_callback_(get_content_callback),
-      document_url_(document_url) {
+      content_url_(content_url) {
   // Make sure we download the content into a temp file.
   if (output_file_path.empty())
     save_temp_file_ = true;
   else
     output_file_path_ = output_file_path;
 }
 
 DownloadFileOperation::~DownloadFileOperation() {}
 
 // Overridden from UrlFetchOperationBase.
 GURL DownloadFileOperation::GetURL() const {
-  return document_url_;
+  return content_url_;
 }
 
 void DownloadFileOperation::OnURLFetchDownloadProgress(const URLFetcher* source,
                                                        int64 current,
                                                        int64 total) {
   NotifyProgress(current, total);
 }
 
 bool DownloadFileOperation::ShouldSendDownloadData() {
   return !get_content_callback_.is_null();
@@ skipping 25 matching lines @@
 void DownloadFileOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   if (!download_action_callback_.is_null())
     download_action_callback_.Run(code, FilePath());
 }
 
 //=========================== DeleteDocumentOperation ==========================
 
 DeleteDocumentOperation::DeleteDocumentOperation(
     OperationRegistry* registry,
     const EntryActionCallback& callback,
-    const GURL& document_url)
+    const GURL& edit_url)
     : EntryActionOperation(registry, callback),
-      document_url_(document_url) {
+      edit_url_(edit_url) {
 }
 
 DeleteDocumentOperation::~DeleteDocumentOperation() {}
 
 GURL DeleteDocumentOperation::GetURL() const {
-  return GDataWapiUrlGenerator::AddStandardUrlParams(document_url_);
+  return GDataWapiUrlGenerator::AddStandardUrlParams(edit_url_);
 }
 
 URLFetcher::RequestType DeleteDocumentOperation::GetRequestType() const {
   return URLFetcher::DELETE_REQUEST;
 }
 
 std::vector<std::string>
 DeleteDocumentOperation::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
   headers.push_back(kIfMatchAllHeader);
@@ skipping 94 matching lines @@
   DVLOG(1) << "CopyDocumentOperation data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 //=========================== RenameResourceOperation ==========================
 
 RenameResourceOperation::RenameResourceOperation(
     OperationRegistry* registry,
     const EntryActionCallback& callback,
-    const GURL& document_url,
+    const GURL& edit_url,
     const FilePath::StringType& new_name)
     : EntryActionOperation(registry, callback),
-      document_url_(document_url),
+      edit_url_(edit_url),
       new_name_(new_name) {
 }
 
 RenameResourceOperation::~RenameResourceOperation() {}
 
 URLFetcher::RequestType RenameResourceOperation::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
 std::vector<std::string>
 RenameResourceOperation::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
   headers.push_back(kIfMatchAllHeader);
   return headers;
 }
 
 GURL RenameResourceOperation::GetURL() const {
-  return GDataWapiUrlGenerator::AddStandardUrlParams(document_url_);
+  return GDataWapiUrlGenerator::AddStandardUrlParams(edit_url_);
 }
 
 bool RenameResourceOperation::GetContentData(std::string* upload_content_type,
                                              std::string* upload_content) {
   upload_content_type->assign("application/atom+xml");
   XmlWriter xml_writer;
   xml_writer.StartWriting();
   xml_writer.StartElement("entry");
   xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
 
   xml_writer.WriteElement("title", FilePath(new_name_).AsUTF8Unsafe());
 
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "RenameResourceOperation data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
 //=========================== AuthorizeAppOperation ==========================
 
 AuthorizeAppOperation::AuthorizeAppOperation(
     OperationRegistry* registry,
     const GetDataCallback& callback,
-    const GURL& document_url,
+    const GURL& edit_url,
     const std::string& app_id)
     : GetDataOperation(registry, callback),
       app_id_(app_id),
-      document_url_(document_url) {
+      edit_url_(edit_url) {
 }
 
 AuthorizeAppOperation::~AuthorizeAppOperation() {}
 
 URLFetcher::RequestType AuthorizeAppOperation::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
 std::vector<std::string>
 AuthorizeAppOperation::GetExtraRequestHeaders() const {
@@ skipping 65 matching lines @@
       link_list->Append(link);
     }
   }
 
   RunCallback(fetch_error_code, link_list.PassAs<base::Value>());
   const bool success = true;
   OnProcessURLFetchResultsComplete(success);
 }
 
 GURL AuthorizeAppOperation::GetURL() const {
-  return document_url_;
+  return edit_url_;
 }
 
 //======================= AddResourceToDirectoryOperation ======================
 
 AddResourceToDirectoryOperation::AddResourceToDirectoryOperation(
     OperationRegistry* registry,
     const GDataWapiUrlGenerator& url_generator,
     const EntryActionCallback& callback,
     const GURL& parent_content_url,
-    const GURL& document_url)
+    const GURL& edit_url)
     : EntryActionOperation(registry, callback),
       url_generator_(url_generator),
       parent_content_url_(parent_content_url),
-      document_url_(document_url) {
+      edit_url_(edit_url) {
 }
 
 AddResourceToDirectoryOperation::~AddResourceToDirectoryOperation() {}
 
 GURL AddResourceToDirectoryOperation::GetURL() const {
   if (!parent_content_url_.is_empty())
     return GDataWapiUrlGenerator::AddStandardUrlParams(parent_content_url_);
 
   return url_generator_.GenerateDocumentListRootUrl();
 }
 
 URLFetcher::RequestType
 AddResourceToDirectoryOperation::GetRequestType() const {
   return URLFetcher::POST;
 }
 
 bool AddResourceToDirectoryOperation::GetContentData(
     std::string* upload_content_type, std::string* upload_content) {
   upload_content_type->assign("application/atom+xml");
   XmlWriter xml_writer;
   xml_writer.StartWriting();
   xml_writer.StartElement("entry");
   xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
 
-  xml_writer.WriteElement("id", document_url_.spec());
+  xml_writer.WriteElement("id", edit_url_.spec());
 
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "AddResourceToDirectoryOperation data: " << *upload_content_type
            << ", [" << *upload_content << "]";
   return true;
 }
 
 //==================== RemoveResourceFromDirectoryOperation ====================
@@ skipping 32 matching lines @@
 }
 
 //=========================== InitiateUploadOperation ==========================
 
 InitiateUploadOperation::InitiateUploadOperation(
     OperationRegistry* registry,
     const InitiateUploadCallback& callback,
     const InitiateUploadParams& params)
     : UrlFetchOperationBase(registry,
                             OPERATION_UPLOAD,
-                            params.virtual_path),
+                            params.drive_file_path),
       callback_(callback),
       params_(params),
       initiate_upload_url_(chrome_common_net::AppendOrReplaceQueryParameter(
           params.upload_location,
           kUploadParamConvertKey,
           kUploadParamConvertValue)) {
 }
 
 InitiateUploadOperation::~InitiateUploadOperation() {}
 
@@ skipping 84 matching lines @@
 }
 
 //============================ ResumeUploadOperation ===========================
 
 ResumeUploadOperation::ResumeUploadOperation(
     OperationRegistry* registry,
     const ResumeUploadCallback& callback,
     const ResumeUploadParams& params)
   : UrlFetchOperationBase(registry,
                           OPERATION_UPLOAD,
-                          params.virtual_path),
+                          params.drive_file_path),
       callback_(callback),
       params_(params),
       last_chunk_completed_(false) {
 }
 
 ResumeUploadOperation::~ResumeUploadOperation() {}
 
 GURL ResumeUploadOperation::GetURL() const {
   return params_.upload_location;
 }
@@ skipping 11 matching lines @@
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
     if (!range_received.empty()) {  // Parse the range header.
       std::vector<net::HttpByteRange> ranges;
       if (net::HttpUtil::ParseRangeHeader(range_received, &ranges) &&
           !ranges.empty() ) {
         // We only care about the first start-end pair in the range.
         start_range_received = ranges[0].first_byte_position();
         end_range_received = ranges[0].last_byte_position();
       }
     }
-    DVLOG(1) << "Got response for [" << params_.virtual_path.value()
+    DVLOG(1) << "Got response for [" << params_.drive_file_path.value()
              << "]: code=" << code
              << ", range_hdr=[" << range_received
              << "], range_parsed=" << start_range_received
              << "," << end_range_received;
   } else {
     // There might be explanation of unexpected error code in response.
     std::string response_content;
     source->GetResponseAsString(&response_content);
-    DVLOG(1) << "Got response for [" << params_.virtual_path.value()
+    DVLOG(1) << "Got response for [" << params_.drive_file_path.value()
              << "]: code=" << code
              << ", content=[\n" << response_content << "\n]";
 
     // Parse entry XML.
     XmlReader xml_reader;
     if (xml_reader.Load(response_content)) {
       while (xml_reader.Read()) {
         if (xml_reader.NodeName() == DocumentEntry::GetEntryNodeName()) {
           entry = DocumentEntry::CreateFromXml(&xml_reader);
           break;
@@ skipping 78 matching lines @@
   return true;
 }
 
 void ResumeUploadOperation::OnURLFetchUploadProgress(
     const URLFetcher* source, int64 current, int64 total) {
   // Adjust the progress values according to the range currently uploaded.
   NotifyProgress(params_.start_range + current, params_.content_length);
 }
 
 }  // namespace google_apis