google_apis: Rename base_operations.h/cc to base_requests.h/cc

chrome/browser/google_apis/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 "chrome/browser/google_apis/base_operations.h"
+#include "chrome/browser/google_apis/base_requests.h"
 
 #include "base/json/json_reader.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/operation_runner.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
 using content::BrowserThread;
 using net::URLFetcher;
 
 namespace {
 
 // Template for optional OAuth2 authorization HTTP header.
 const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
 // Template for GData API version HTTP header.
 const char kGDataVersionHeader[] = "GData-Version: 3.0";
 
-// Maximum number of attempts for re-authentication per operation.
-const int kMaxReAuthenticateAttemptsPerOperation = 1;
+// Maximum number of attempts for re-authentication per request.
+const int kMaxReAuthenticateAttemptsPerRequest = 1;
 
 // Template for initiate upload of both GData WAPI and Drive API v2.
 const char kUploadContentType[] = "X-Upload-Content-Type: ";
 const char kUploadContentLength[] = "X-Upload-Content-Length: ";
 const char kUploadResponseLocation[] = "location";
 
 // Template for upload data range of both GData WAPI and Drive API v2.
 const char kUploadContentRange[] = "Content-Range: bytes ";
 const char kUploadResponseRange[] = "range";
 
@@ skipping 38 matching lines @@
 namespace google_apis {
 
 void ParseJson(const std::string& json, const ParseJsonCallback& callback) {
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&ParseJsonOnBlockingPool, json),
       callback);
 }
 
-//============================ UrlFetchOperationBase ===========================
+//============================ UrlFetchRequestBase ===========================
 
-UrlFetchOperationBase::UrlFetchOperationBase(
+UrlFetchRequestBase::UrlFetchRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter)
     : OperationRegistry::Operation(runner->operation_registry()),
       url_request_context_getter_(url_request_context_getter),
       re_authenticate_count_(0),
       started_(false),
       save_temp_file_(false),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-UrlFetchOperationBase::UrlFetchOperationBase(
+UrlFetchRequestBase::UrlFetchRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const base::FilePath& path)
     : OperationRegistry::Operation(runner->operation_registry(), path),
       url_request_context_getter_(url_request_context_getter),
       re_authenticate_count_(0),
       started_(false),
       save_temp_file_(false),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-UrlFetchOperationBase::~UrlFetchOperationBase() {}
+UrlFetchRequestBase::~UrlFetchRequestBase() {}
 
-void UrlFetchOperationBase::Start(const std::string& access_token,
-                                  const std::string& custom_user_agent,
-                                  const ReAuthenticateCallback& callback) {
+void UrlFetchRequestBase::Start(const std::string& access_token,
+                                const std::string& custom_user_agent,
+                                const ReAuthenticateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(url_request_context_getter_);
   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()) {
@@ skipping 10 matching lines @@
       URLFetcher::Create(url, request_type, this));
   url_fetcher_->SetRequestContext(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 |
       net::LOAD_DISABLE_CACHE);
   if (save_temp_file_) {
     url_fetcher_->SaveResponseToTemporaryFile(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   } else if (!output_file_path_.empty()) {
-    url_fetcher_->SaveResponseToFileAtPath(output_file_path_,
+    url_fetcher_->SaveResponseToFileAtPath(
+        output_file_path_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   }
 
   // Add request headers.
   // Note that SetExtraRequestHeaders clears the current headers and sets it
   // to the passed-in headers, so calling it for each header will result in
   // only the last header being set in request headers.
   if (!custom_user_agent.empty())
     url_fetcher_->AddExtraRequestHeader("User-Agent: " + custom_user_agent);
   url_fetcher_->AddExtraRequestHeader(kGDataVersionHeader);
   url_fetcher_->AddExtraRequestHeader(
-        base::StringPrintf(kAuthorizationHeaderFormat, access_token.data()));
+      base::StringPrintf(kAuthorizationHeaderFormat, access_token.data()));
   std::vector<std::string> headers = GetExtraRequestHeaders();
   for (size_t i = 0; i < headers.size(); ++i) {
     url_fetcher_->AddExtraRequestHeader(headers[i]);
     DVLOG(1) << "Extra header: " << headers[i];
   }
 
   // Set upload data if available.
   std::string upload_content_type;
   std::string upload_content;
   if (GetContentData(&upload_content_type, &upload_content)) {
@@ skipping 25 matching lines @@
     }
   }
 
   // Register to operation registry.
   NotifyStartToOperationRegistry();
 
   url_fetcher_->Start();
   started_ = true;
 }
 
-URLFetcher::RequestType UrlFetchOperationBase::GetRequestType() const {
+URLFetcher::RequestType UrlFetchRequestBase::GetRequestType() const {
   return URLFetcher::GET;
 }
 
-std::vector<std::string> UrlFetchOperationBase::GetExtraRequestHeaders() const {
+std::vector<std::string> UrlFetchRequestBase::GetExtraRequestHeaders() const {
   return std::vector<std::string>();
 }
 
-bool UrlFetchOperationBase::GetContentData(std::string* upload_content_type,
-                                           std::string* upload_content) {
+bool UrlFetchRequestBase::GetContentData(std::string* upload_content_type,
+                                         std::string* upload_content) {
   return false;
 }
 
-bool UrlFetchOperationBase::GetContentFile(base::FilePath* local_file_path,
-                                           int64* range_offset,
-                                           int64* range_length,
-                                           std::string* upload_content_type) {
+bool UrlFetchRequestBase::GetContentFile(base::FilePath* local_file_path,
+                                         int64* range_offset,
+                                         int64* range_length,
+                                         std::string* upload_content_type) {
   return false;
 }
 
-void UrlFetchOperationBase::DoCancel() {
+void UrlFetchRequestBase::DoCancel() {
   url_fetcher_.reset(NULL);
   RunCallbackOnPrematureFailure(GDATA_CANCELLED);
 }
 
 // static
-GDataErrorCode UrlFetchOperationBase::GetErrorCode(const URLFetcher* source) {
+GDataErrorCode UrlFetchRequestBase::GetErrorCode(const URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
   if (!source->GetStatus().is_success()) {
     switch (source->GetStatus().error()) {
       case net::ERR_NETWORK_CHANGED:
         code = GDATA_NO_CONNECTION;
         break;
       default:
         code = GDATA_OTHER_ERROR;
     }
   }
   return code;
 }
 
-void UrlFetchOperationBase::OnProcessURLFetchResultsComplete(bool result) {
+void UrlFetchRequestBase::OnProcessURLFetchResultsComplete(bool result) {
   if (result)
     NotifySuccessToOperationRegistry();
   else
     NotifyFinish(OPERATION_FAILED);
 }
 
-void UrlFetchOperationBase::OnURLFetchComplete(const URLFetcher* source) {
+void UrlFetchRequestBase::OnURLFetchComplete(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
-    if (++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerOperation) {
+    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(code);
     return;
   }
 
   // Overridden by each specialization
   ProcessURLFetchResults(source);
 }
 
-void UrlFetchOperationBase::NotifySuccessToOperationRegistry() {
+void UrlFetchRequestBase::NotifySuccessToOperationRegistry() {
   NotifyFinish(OPERATION_COMPLETED);
 }
 
-void UrlFetchOperationBase::NotifyStartToOperationRegistry() {
+void UrlFetchRequestBase::NotifyStartToOperationRegistry() {
   NotifyStart();
 }
 
-void UrlFetchOperationBase::OnAuthFailed(GDataErrorCode code) {
+void UrlFetchRequestBase::OnAuthFailed(GDataErrorCode code) {
   RunCallbackOnPrematureFailure(code);
 
   // Check if this failed before we even started fetching. If so, register
   // for start so we can properly unregister with finish.
   if (!started_)
     NotifyStart();
 
   // Note: NotifyFinish() must be invoked at the end, after all other callbacks
   // and notifications. Once NotifyFinish() is called, the current instance of
-  // gdata operation will be deleted from the OperationRegistry and become
-  // invalid.
+  // request will be deleted from the OperationRegistry and become invalid.
   NotifyFinish(OPERATION_FAILED);
 }
 
-base::WeakPtr<AuthenticatedOperationInterface>
-UrlFetchOperationBase::GetWeakPtr() {
+base::WeakPtr<AuthenticatedRequestInterface>
+UrlFetchRequestBase::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-//============================ EntryActionOperation ============================
+//============================ EntryActionRequest ============================
 
-EntryActionOperation::EntryActionOperation(
+EntryActionRequest::EntryActionRequest(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const EntryActionCallback& callback)
-    : UrlFetchOperationBase(runner, url_request_context_getter),
+    : UrlFetchRequestBase(runner, url_request_context_getter),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
-EntryActionOperation::~EntryActionOperation() {}
+EntryActionRequest::~EntryActionRequest() {}
 
-void EntryActionOperation::ProcessURLFetchResults(const URLFetcher* source) {
+void EntryActionRequest::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   callback_.Run(code);
   const bool success = true;
   OnProcessURLFetchResultsComplete(success);
 }
 
-void EntryActionOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void EntryActionRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   callback_.Run(code);
 }
 
-//============================== GetDataOperation ==============================
+//============================== GetDataRequest ==============================
 
-GetDataOperation::GetDataOperation(
+GetDataRequest::GetDataRequest(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const GetDataCallback& callback)
-    : UrlFetchOperationBase(runner, url_request_context_getter),
+    : UrlFetchRequestBase(runner, url_request_context_getter),
       callback_(callback),
       weak_ptr_factory_(this) {
   DCHECK(!callback_.is_null());
 }
 
-GetDataOperation::~GetDataOperation() {}
+GetDataRequest::~GetDataRequest() {}
 
-void GetDataOperation::ParseResponse(GDataErrorCode fetch_error_code,
-                                     const std::string& data) {
+void GetDataRequest::ParseResponse(GDataErrorCode fetch_error_code,
+                                   const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(1) << "JSON received from " << GetURL().spec() << ": "
           << data.size() << " bytes";
   ParseJson(data,
-            base::Bind(&GetDataOperation::OnDataParsed,
+            base::Bind(&GetDataRequest::OnDataParsed,
                        weak_ptr_factory_.GetWeakPtr(),
                        fetch_error_code));
 }
 
-void GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
+void GetDataRequest::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
   GDataErrorCode fetch_error_code = GetErrorCode(source);
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
       ParseResponse(fetch_error_code, data);
       break;
     default:
       RunCallbackOnPrematureFailure(fetch_error_code);
       const bool success = false;
       OnProcessURLFetchResultsComplete(success);
       break;
   }
 }
 
-void GetDataOperation::RunCallbackOnPrematureFailure(
+void GetDataRequest::RunCallbackOnPrematureFailure(
     GDataErrorCode fetch_error_code) {
   callback_.Run(fetch_error_code, scoped_ptr<base::Value>());
 }
 
-void GetDataOperation::OnDataParsed(
+void GetDataRequest::OnDataParsed(
     GDataErrorCode fetch_error_code,
     scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool success = true;
   if (!value.get()) {
     fetch_error_code = GDATA_PARSE_ERROR;
     success = false;
   }
 
   RunCallbackOnSuccess(fetch_error_code, value.Pass());
 
   DCHECK(!value.get());
   OnProcessURLFetchResultsComplete(success);
 }
 
-void GetDataOperation::RunCallbackOnSuccess(GDataErrorCode fetch_error_code,
-                                            scoped_ptr<base::Value> value) {
+void GetDataRequest::RunCallbackOnSuccess(GDataErrorCode fetch_error_code,
+                                          scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback_.Run(fetch_error_code, value.Pass());
 }
 
-//========================= InitiateUploadOperationBase ========================
+//========================= InitiateUploadRequestBase ========================
 
-InitiateUploadOperationBase::InitiateUploadOperationBase(
+InitiateUploadRequestBase::InitiateUploadRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const InitiateUploadCallback& callback,
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length)
-    : UrlFetchOperationBase(runner,
-                            url_request_context_getter,
-                            drive_file_path),
+    : UrlFetchRequestBase(runner,
+                          url_request_context_getter,
+                          drive_file_path),
       callback_(callback),
       drive_file_path_(drive_file_path),
       content_type_(content_type),
       content_length_(content_length) {
   DCHECK(!callback_.is_null());
   DCHECK(!content_type_.empty());
   DCHECK_GE(content_length_, 0);
 }
 
-InitiateUploadOperationBase::~InitiateUploadOperationBase() {}
+InitiateUploadRequestBase::~InitiateUploadRequestBase() {}
 
-void InitiateUploadOperationBase::ProcessURLFetchResults(
+void InitiateUploadRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
   GDataErrorCode 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 [" << drive_file_path_.value()
           << "]: code=" << code
           << ", location=[" << upload_location << "]";
 
   callback_.Run(code, GURL(upload_location));
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
-void InitiateUploadOperationBase::NotifySuccessToOperationRegistry() {
+void InitiateUploadRequestBase::NotifySuccessToOperationRegistry() {
   NotifySuspend();
 }
 
-void InitiateUploadOperationBase::RunCallbackOnPrematureFailure(
+void InitiateUploadRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   callback_.Run(code, GURL());
 }
 
 std::vector<std::string>
-InitiateUploadOperationBase::GetExtraRequestHeaders() const {
+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,
                                          int64 start_position_received,
                                          int64 end_position_received)
     : code(code),
       start_position_received(start_position_received),
       end_position_received(end_position_received) {
 }
 
 UploadRangeResponse::~UploadRangeResponse() {
 }
 
-//========================== UploadRangeOperationBase ==========================
+//========================== UploadRangeRequestBase ==========================
 
-UploadRangeOperationBase::UploadRangeOperationBase(
+UploadRangeRequestBase::UploadRangeRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const base::FilePath& drive_file_path,
     const GURL& upload_url)
-    : UrlFetchOperationBase(runner,
-                            url_request_context_getter,
-                            drive_file_path),
+    : UrlFetchRequestBase(runner,
+                          url_request_context_getter,
+                          drive_file_path),
       drive_file_path_(drive_file_path),
       upload_url_(upload_url),
       last_chunk_completed_(false),
       weak_ptr_factory_(this) {
 }
 
-UploadRangeOperationBase::~UploadRangeOperationBase() {}
+UploadRangeRequestBase::~UploadRangeRequestBase() {}
 
-GURL UploadRangeOperationBase::GetURL() const {
-  // This is very tricky to get json from this operation. To do that, &alt=json
-  // has to be appended not here but in InitiateUploadOperation::GetURL().
+GURL UploadRangeRequestBase::GetURL() const {
+  // This is very tricky to get json from this request. To do that, &alt=json
+  // has to be appended not here but in InitiateUploadRequestBase::GetURL().
   return upload_url_;
 }
 
-URLFetcher::RequestType UploadRangeOperationBase::GetRequestType() const {
+URLFetcher::RequestType UploadRangeRequestBase::GetRequestType() const {
   return URLFetcher::PUT;
 }
 
-void UploadRangeOperationBase::ProcessURLFetchResults(
+void UploadRangeRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   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;
@@ skipping 15 matching lines @@
     }
     // The Range header has the received data range, so the start position
     // should be always 0.
     DCHECK_EQ(start_position_received, 0);
     DVLOG(1) << "Got response for [" << drive_file_path_.value()
              << "]: code=" << code
              << ", range_hdr=[" << range_received
              << "], range_parsed=" << start_position_received
              << "," << end_position_received;
 
-    OnRangeOperationComplete(UploadRangeResponse(code,
-                                                 start_position_received,
-                                                 end_position_received),
-                             scoped_ptr<base::Value>());
+    OnRangeRequestComplete(UploadRangeResponse(code,
+                                               start_position_received,
+                                               end_position_received),
+                           scoped_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete(true);
   } else {
     // There might be explanation of unexpected error code in response.
     std::string response_content;
     source->GetResponseAsString(&response_content);
     DVLOG(1) << "Got response for [" << drive_file_path_.value()
              << "]: code=" << code
              << ", content=[\n" << response_content << "\n]";
 
     ParseJson(response_content,
-              base::Bind(&UploadRangeOperationBase::OnDataParsed,
+              base::Bind(&UploadRangeRequestBase::OnDataParsed,
                          weak_ptr_factory_.GetWeakPtr(),
                          code));
   }
 }
 
-void UploadRangeOperationBase::OnDataParsed(GDataErrorCode code,
-                                            scoped_ptr<base::Value> value) {
+void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
+                                          scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // For a new file, HTTP_CREATED is returned.
   // For an existing file, HTTP_SUCCESS is returned.
   if (code == HTTP_CREATED || code == HTTP_SUCCESS)
     last_chunk_completed_ = true;
 
-  OnRangeOperationComplete(UploadRangeResponse(code, -1, -1), value.Pass());
+  OnRangeRequestComplete(UploadRangeResponse(code, -1, -1), value.Pass());
   OnProcessURLFetchResultsComplete(last_chunk_completed_);
 }
 
-void UploadRangeOperationBase::NotifySuccessToOperationRegistry() {
+void UploadRangeRequestBase::NotifySuccessToOperationRegistry() {
   if (last_chunk_completed_)
     NotifyFinish(OPERATION_COMPLETED);
   else
     NotifySuspend();
 }
 
-void UploadRangeOperationBase::RunCallbackOnPrematureFailure(
+void UploadRangeRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
-  OnRangeOperationComplete(
+  OnRangeRequestComplete(
       UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
 }
 
-//========================== ResumeUploadOperationBase =========================
+//========================== ResumeUploadRequestBase =========================
 
-ResumeUploadOperationBase::ResumeUploadOperationBase(
+ResumeUploadRequestBase::ResumeUploadRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const base::FilePath& drive_file_path,
     const GURL& upload_location,
     int64 start_position,
     int64 end_position,
     int64 content_length,
     const std::string& content_type,
     const base::FilePath& local_file_path)
-    : UploadRangeOperationBase(runner,
-                               url_request_context_getter,
-                               drive_file_path,
-                               upload_location),
+    : UploadRangeRequestBase(runner,
+                             url_request_context_getter,
+                             drive_file_path,
+                             upload_location),
       start_position_(start_position),
       end_position_(end_position),
       content_length_(content_length),
       content_type_(content_type),
       local_file_path_(local_file_path) {
   DCHECK_LE(start_position_, end_position_);
 }
 
-ResumeUploadOperationBase::~ResumeUploadOperationBase() {}
+ResumeUploadRequestBase::~ResumeUploadRequestBase() {}
 
 std::vector<std::string>
-ResumeUploadOperationBase::GetExtraRequestHeaders() const {
+ResumeUploadRequestBase::GetExtraRequestHeaders() const {
   if (content_length_ == 0) {
     // For uploading an empty document, just PUT an empty content.
     DCHECK_EQ(start_position_, 0);
     DCHECK_EQ(end_position_, 0);
     return std::vector<std::string>();
   }
 
   // The header looks like
   // Content-Range: bytes <start_position>-<end_position>/<content_length>
   // for example:
   // Content-Range: bytes 7864320-8388607/13851821
   // The header takes inclusive range, so we adjust by "end_position - 1".
   DCHECK_GE(start_position_, 0);
   DCHECK_GT(end_position_, 0);
   DCHECK_GE(content_length_, 0);
 
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) +
       base::Int64ToString(start_position_) + "-" +
       base::Int64ToString(end_position_ - 1) + "/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
-bool ResumeUploadOperationBase::GetContentFile(
+bool ResumeUploadRequestBase::GetContentFile(
     base::FilePath* local_file_path,
     int64* range_offset,
     int64* range_length,
     std::string* upload_content_type) {
   if (start_position_ == end_position_) {
     // No content data.
     return false;
   }
 
   *local_file_path = local_file_path_;
   *range_offset = start_position_;
   *range_length = end_position_ - start_position_;
   *upload_content_type = content_type_;
   return true;
 }
 
-void ResumeUploadOperationBase::NotifyStartToOperationRegistry() {
+void ResumeUploadRequestBase::NotifyStartToOperationRegistry() {
   NotifyResume();
 }
 
-//======================== GetUploadStatusOperationBase ========================
+//======================== GetUploadStatusRequestBase ========================
 
-GetUploadStatusOperationBase::GetUploadStatusOperationBase(
+GetUploadStatusRequestBase::GetUploadStatusRequestBase(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length)
-  : UploadRangeOperationBase(runner,
+    : UploadRangeRequestBase(runner,
                              url_request_context_getter,
                              drive_file_path,
                              upload_url),
-    content_length_(content_length) {}
+      content_length_(content_length) {}
 
-GetUploadStatusOperationBase::~GetUploadStatusOperationBase() {}
+GetUploadStatusRequestBase::~GetUploadStatusRequestBase() {}
 
 std::vector<std::string>
-GetUploadStatusOperationBase::GetExtraRequestHeaders() const {
+GetUploadStatusRequestBase::GetExtraRequestHeaders() const {
   // The header looks like
   // Content-Range: bytes */<content_length>
   // for example:
   // Content-Range: bytes */13851821
   DCHECK_GE(content_length_, 0);
 
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) + "*/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
-//============================ DownloadFileOperation ===========================
+//============================ DownloadFileRequest ===========================
 
-DownloadFileOperation::DownloadFileOperation(
+DownloadFileRequest::DownloadFileRequest(
     OperationRunner* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback,
     const GURL& download_url,
     const base::FilePath& drive_file_path,
     const base::FilePath& output_file_path)
-    : UrlFetchOperationBase(runner,
-                            url_request_context_getter,
-                            drive_file_path),
+    : UrlFetchRequestBase(runner,
+                          url_request_context_getter,
+                          drive_file_path),
       download_action_callback_(download_action_callback),
       get_content_callback_(get_content_callback),
       progress_callback_(progress_callback),
       download_url_(download_url) {
   DCHECK(!download_action_callback_.is_null());
   // get_content_callback may be null.
 
   // Make sure we download the content into a temp file.
   if (output_file_path.empty())
     set_save_temp_file(true);
   else
     set_output_file_path(output_file_path);
 }
 
-DownloadFileOperation::~DownloadFileOperation() {}
+DownloadFileRequest::~DownloadFileRequest() {}
 
-// Overridden from UrlFetchOperationBase.
-GURL DownloadFileOperation::GetURL() const {
+// Overridden from UrlFetchRequestBase.
+GURL DownloadFileRequest::GetURL() const {
   return download_url_;
 }
 
-void DownloadFileOperation::OnURLFetchDownloadProgress(const URLFetcher* source,
-                                                       int64 current,
-                                                       int64 total) {
+void DownloadFileRequest::OnURLFetchDownloadProgress(const URLFetcher* source,
+                                                     int64 current,
+                                                     int64 total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
-bool DownloadFileOperation::ShouldSendDownloadData() {
+bool DownloadFileRequest::ShouldSendDownloadData() {
   return !get_content_callback_.is_null();
 }
 
-void DownloadFileOperation::OnURLFetchDownloadData(
+void DownloadFileRequest::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) {
+void DownloadFileRequest::ProcessURLFetchResults(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   // Take over the ownership of the the downloaded temp file.
   base::FilePath temp_file;
   if (code == HTTP_SUCCESS &&
       !source->GetResponseAsFilePath(true,  // take_ownership
                                      &temp_file)) {
     code = GDATA_FILE_ERROR;
   }
 
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
-void DownloadFileOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
+void DownloadFileRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis