Replace most of the occurrence of OperationRegistry with OperationRunner.

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"
@@ skipping 256 matching lines @@
   return HasRefreshToken();
 }
 
 void DriveAPIService::CancelAll() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   runner_->CancelAll();
 }
 
 bool DriveAPIService::CancelForFilePath(const base::FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return operation_registry()->CancelForFilePath(file_path);
+  return runner_->operation_registry()->CancelForFilePath(file_path);
 }
 
 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(
       new GetChangelistOperation(
-          operation_registry(),
+          runner_.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(
       new GetFilelistOperation(
-          operation_registry(),
+          runner_.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(
       new GetFilelistOperation(
-          operation_registry(),
+          runner_.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(
       new GetFilelistOperation(
-          operation_registry(),
+          runner_.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(
       new GetChangelistOperation(
-          operation_registry(),
+          runner_.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(
       new drive::ContinueGetFileListOperation(
-          operation_registry(),
+          runner_.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(
-      operation_registry(),
+      runner_.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(
       new GetAboutOperation(
-          operation_registry(),
+          runner_.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(
-      operation_registry(),
+      runner_.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 DownloadFileOperation(operation_registry(),
+      new DownloadFileOperation(runner_.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(
-      operation_registry(),
+      runner_.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(
       new drive::CreateDirectoryOperation(
-          operation_registry(),
+          runner_.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(
       new drive::CopyResourceOperation(
-          operation_registry(),
+          runner_.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(
       new drive::CopyResourceOperation(
-          operation_registry(),
+          runner_.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(
       new drive::RenameResourceOperation(
-          operation_registry(),
+          runner_.get(),
           url_request_context_getter_,
           url_generator_,
           resource_id,
           new_name,
           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(
       new drive::InsertResourceOperation(
-          operation_registry(),
+          runner_.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(
       new drive::DeleteResourceOperation(
-          operation_registry(),
+          runner_.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(
       new drive::InitiateUploadNewFileOperation(
-          operation_registry(),
+          runner_.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(
       new drive::InitiateUploadExistingFileOperation(
-          operation_registry(),
+          runner_.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(
       new drive::ResumeUploadOperation(
-          operation_registry(),
+          runner_.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(
-      operation_registry(),
+      runner_.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(
-      operation_registry(),
+      runner_.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();
 }
 
 bool DriveAPIService::HasRefreshToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return runner_->auth_service()->HasRefreshToken();
 }
 
 void DriveAPIService::ClearAccessToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return runner_->auth_service()->ClearAccessToken();
 }
 
 void DriveAPIService::ClearRefreshToken() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return runner_->auth_service()->ClearRefreshToken();
 }
 
-OperationRegistry* DriveAPIService::operation_registry() const {
-  return runner_->operation_registry();
-}
-
 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