google_apis: Rename OperationRunner to RequestSender

chrome/browser/google_apis/drive_api_service.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/drive_api_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/auth_service.h"
 #include "chrome/browser/google_apis/drive_api_operations.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/drive_api_util.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
-#include "chrome/browser/google_apis/operation_runner.h"
+#include "chrome/browser/google_apis/request_sender.h"
 #include "chrome/browser/google_apis/time_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace google_apis {
 
 namespace {
 
@@ skipping 186 matching lines @@
 const char kDriveApiRootDirectoryResourceId[] = "root";
 
 }  // namespace
 
 DriveAPIService::DriveAPIService(
     net::URLRequestContextGetter* url_request_context_getter,
     const GURL& base_url,
     const std::string& custom_user_agent)
     : url_request_context_getter_(url_request_context_getter),
       profile_(NULL),
-      runner_(NULL),
+      sender_(NULL),
       url_generator_(base_url),
       custom_user_agent_(custom_user_agent) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 DriveAPIService::~DriveAPIService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (runner_.get())
-    runner_->auth_service()->RemoveObserver(this);
+  if (sender_.get())
+    sender_->auth_service()->RemoveObserver(this);
 }
 
 void DriveAPIService::Initialize(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   profile_ = profile;
 
   std::vector<std::string> scopes;
   scopes.push_back(kDriveScope);
   scopes.push_back(kDriveAppsReadonlyScope);
-  runner_.reset(new OperationRunner(profile,
-                                    url_request_context_getter_,
-                                    scopes,
-                                    custom_user_agent_));
-  runner_->Initialize();
+  sender_.reset(new RequestSender(profile,
+                                  url_request_context_getter_,
+                                  scopes,
+                                  custom_user_agent_));
+  sender_->Initialize();
 
-  runner_->auth_service()->AddObserver(this);
+  sender_->auth_service()->AddObserver(this);
 }
 
 void DriveAPIService::AddObserver(DriveServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void DriveAPIService::RemoveObserver(DriveServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool DriveAPIService::CanStartOperation() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return HasRefreshToken();
 }
 
 void DriveAPIService::CancelAll() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  runner_->CancelAll();
+  sender_->CancelAll();
 }
 
 bool DriveAPIService::CancelForFilePath(const base::FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return runner_->operation_registry()->CancelForFilePath(file_path);
+  return sender_->operation_registry()->CancelForFilePath(file_path);
 }
 
 std::string DriveAPIService::CanonicalizeResourceId(
     const std::string& resource_id) const {
   return drive::util::CanonicalizeResourceId(resource_id);
 }
 
 std::string DriveAPIService::GetRootResourceId() const {
   return kDriveApiRootDirectoryResourceId;
 }
 
 void DriveAPIService::GetAllResourceList(
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // The simplest way to fetch the all resources list looks files.list method,
   // but it seems impossible to know the returned list's changestamp.
   // Thus, instead, we use changes.list method with includeDeleted=false here.
   // The returned list should contain only resources currently existing.
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetChangelistOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           false,  // include deleted
           0,
           kMaxNumFilesResourcePerRequest,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::GetResourceListInDirectory(
     const std::string& directory_resource_id,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!directory_resource_id.empty());
   DCHECK(!callback.is_null());
 
   // Because children.list method on Drive API v2 returns only the list of
   // children's references, but we need all file resource list.
   // So, here we use files.list method instead, with setting parents query.
   // After the migration from GData WAPI to Drive API v2, we should clean the
   // code up by moving the resposibility to include "parents" in the query
   // to client side.
   // We aren't interested in files in trash in this context, neither.
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetFilelistOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           base::StringPrintf(
               "'%s' in parents and trashed = false",
               drive::util::EscapeQueryStringValue(
                   directory_resource_id).c_str()),
           kMaxNumFilesResourcePerRequest,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::Search(const std::string& search_query,
                              const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!search_query.empty());
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetFilelistOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           drive::util::TranslateQuery(search_query),
           kMaxNumFilesResourcePerRequestForSearch,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::SearchByTitle(
     const std::string& title,
     const std::string& directory_resource_id,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!title.empty());
   DCHECK(!callback.is_null());
 
   std::string query;
   base::StringAppendF(&query, "title = '%s'",
                       drive::util::EscapeQueryStringValue(title).c_str());
   if (!directory_resource_id.empty()) {
     base::StringAppendF(
         &query, " and '%s' in parents",
         drive::util::EscapeQueryStringValue(directory_resource_id).c_str());
   }
   query += " and trashed = false";
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetFilelistOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           query,
           kMaxNumFilesResourcePerRequest,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::GetChangeList(int64 start_changestamp,
                                     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetChangelistOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           true,  // include deleted
           start_changestamp,
           kMaxNumFilesResourcePerRequest,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::ContinueGetResourceList(
     const GURL& override_url,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::ContinueGetFileListOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           override_url,
           base::Bind(&ParseResourceListOnBlockingPoolAndRun, callback)));
 }
 
 void DriveAPIService::GetResourceEntry(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(new GetFileOperation(
-      runner_.get(),
+  sender_->StartRequestWithRetry(new GetFileOperation(
+      sender_.get(),
       url_request_context_getter_,
       url_generator_,
       resource_id,
       base::Bind(&ParseResourceEntryAndRun, callback)));
 }
 
 void DriveAPIService::GetAboutResource(
     const GetAboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new GetAboutOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           callback));
 }
 
 void DriveAPIService::GetAppList(const GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(new GetApplistOperation(
-      runner_.get(),
+  sender_->StartRequestWithRetry(new GetApplistOperation(
+      sender_.get(),
       url_request_context_getter_,
       url_generator_,
       base::Bind(&ParseAppListAndRun, callback)));
 }
 
 void DriveAPIService::DownloadFile(
     const base::FilePath& virtual_path,
     const base::FilePath& local_cache_path,
     const GURL& download_url,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_action_callback.is_null());
   // get_content_callback may be null.
 
-  runner_->StartOperationWithRetry(
-      new DownloadFileRequest(runner_.get(),
+  sender_->StartRequestWithRetry(
+      new DownloadFileRequest(sender_.get(),
                               url_request_context_getter_,
                               download_action_callback,
                               get_content_callback,
                               progress_callback,
                               download_url,
                               virtual_path,
                               local_cache_path));
 }
 
 void DriveAPIService::DeleteResource(
     const std::string& resource_id,
     const std::string& etag,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(new drive::TrashResourceOperation(
-      runner_.get(),
+  sender_->StartRequestWithRetry(new drive::TrashResourceOperation(
+      sender_.get(),
       url_request_context_getter_,
       url_generator_,
       resource_id,
       callback));
 }
 
 void DriveAPIService::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::CreateDirectoryOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           parent_resource_id,
           directory_name,
           base::Bind(&ParseResourceEntryAndRun, callback)));
 }
 
 void DriveAPIService::CopyResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::CopyResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           resource_id,
           parent_resource_id,
           new_name,
           base::Bind(&ParseResourceEntryAndRun, callback)));
 }
 
 void DriveAPIService::CopyHostedDocument(
     const std::string& resource_id,
     const std::string& new_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::CopyResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           resource_id,
           std::string(),  // parent_resource_id.
           new_name,
           base::Bind(&ParseResourceEntryAndRun, callback)));
 }
 
 void DriveAPIService::RenameResource(
     const std::string& resource_id,
     const std::string& new_name,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::RenameResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           resource_id,
           new_name,
           callback));
 }
 
 void DriveAPIService::TouchResource(
     const std::string& resource_id,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!modified_date.is_null());
   DCHECK(!last_viewed_by_me_date.is_null());
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::TouchResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           resource_id,
           modified_date,
           last_viewed_by_me_date,
           base::Bind(&ParseResourceEntryAndRun, callback)));
 }
 
 void DriveAPIService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::InsertResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           parent_resource_id,
           resource_id,
           callback));
 }
 
 void DriveAPIService::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::DeleteResourceOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           parent_resource_id,
           resource_id,
           callback));
 }
 
 void DriveAPIService::InitiateUploadNewFile(
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::InitiateUploadNewFileOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           drive_file_path,
           content_type,
           content_length,
           parent_resource_id,
           title,
           callback));
 }
 
 void DriveAPIService::InitiateUploadExistingFile(
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length,
     const std::string& resource_id,
     const std::string& etag,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::InitiateUploadExistingFileOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           url_generator_,
           drive_file_path,
           content_type,
           content_length,
           resource_id,
           etag,
           callback));
 }
 
 void DriveAPIService::ResumeUpload(
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 start_position,
     int64 end_position,
     int64 content_length,
     const std::string& content_type,
     const base::FilePath& local_file_path,
     const UploadRangeCallback& callback,
     const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(
+  sender_->StartRequestWithRetry(
       new drive::ResumeUploadOperation(
-          runner_.get(),
+          sender_.get(),
           url_request_context_getter_,
           drive_file_path,
           upload_url,
           start_position,
           end_position,
           content_length,
           content_type,
           local_file_path,
           base::Bind(&ParseResourceEntryForUploadRangeAndRun, callback),
           progress_callback));
 }
 
 void DriveAPIService::GetUploadStatus(
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(new drive::GetUploadStatusOperation(
-      runner_.get(),
+  sender_->StartRequestWithRetry(new drive::GetUploadStatusOperation(
+      sender_.get(),
       url_request_context_getter_,
       drive_file_path,
       upload_url,
       content_length,
       base::Bind(&ParseResourceEntryForUploadRangeAndRun, callback)));
 }
 
 void DriveAPIService::AuthorizeApp(
     const std::string& resource_id,
     const std::string& app_id,
     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  runner_->StartOperationWithRetry(new GetFileOperation(
-      runner_.get(),
+  sender_->StartRequestWithRetry(new GetFileOperation(
+      sender_.get(),
       url_request_context_getter_,
       url_generator_,
       resource_id,
       base::Bind(&ExtractOpenUrlAndRun, app_id, callback)));
 }
 
 bool DriveAPIService::HasAccessToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  return runner_->auth_service()->HasAccessToken();
+  return sender_->auth_service()->HasAccessToken();
 }
 
 bool DriveAPIService::HasRefreshToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  return runner_->auth_service()->HasRefreshToken();
+  return sender_->auth_service()->HasRefreshToken();
 }
 
 void DriveAPIService::ClearAccessToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return runner_->auth_service()->ClearAccessToken();
+  return sender_->auth_service()->ClearAccessToken();
 }
 
 void DriveAPIService::ClearRefreshToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return runner_->auth_service()->ClearRefreshToken();
+  return sender_->auth_service()->ClearRefreshToken();
 }
 
 void DriveAPIService::OnOAuth2RefreshTokenChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (CanStartOperation()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnReadyToPerformOperations());
   } else if (!HasRefreshToken()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnRefreshTokenInvalid());
   }
 }
 
 }  // namespace google_apis