Support cancellation of non-yet-running jobs in drive::JobScheduler.

chrome/browser/chromeos/drive/job_scheduler.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/drive/job_scheduler.h"
 
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 71 matching lines @@
 google_apis::CancelCallback RunResumeUploadFile(
     DriveUploaderInterface* uploader,
     const ResumeUploadFileParams& params) {
   return uploader->ResumeUploadFile(params.upload_location,
                                     params.local_file_path,
                                     params.content_type,
                                     params.callback,
                                     params.progress_callback);
 }
 
+// Helper for CreateErrorRunCallback.
+template<typename P1>
+struct CreateErrorRunCallbackHelper {
+  static void Run(
+      const base::Callback<void(google_apis::GDataErrorCode, P1)>& callback,
+      google_apis::GDataErrorCode error) {
+    callback.Run(error, P1());
+  }
+};
+
+template<typename P1>
+struct CreateErrorRunCallbackHelper<const P1&> {
+  static void Run(
+      const base::Callback<void(google_apis::GDataErrorCode,
+                                const P1&)>& callback,
+      google_apis::GDataErrorCode error) {
+    callback.Run(error, P1());
+  }
+};
+
+// Returns a callback with the tail parameter bound to its default value.
+// In other words, returned_callback.Run(error) runs callback.Run(error, T()).
+template<typename P1>
+base::Callback<void(google_apis::GDataErrorCode)> CreateErrorRunCallback(
+    const base::Callback<void(google_apis::GDataErrorCode, P1)>& callback) {
+  return base::Bind(&CreateErrorRunCallbackHelper<P1>::Run, callback);
+}
+
 }  // namespace
 
 const int JobScheduler::kMaxJobCount[] = {
   5,  // METADATA_QUEUE
   1,  // FILE_QUEUE
 };
 
 JobScheduler::JobEntry::JobEntry(JobType type)
     : job_info(type),
       context(ClientContext(USER_INITIATED)),
@@ skipping 54 matching lines @@
 void JobScheduler::RemoveObserver(JobListObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.RemoveObserver(observer);
 }
 
 void JobScheduler::CancelJob(JobID job_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* job = job_map_.Lookup(job_id);
   if (job) {
-    // TODO(kinaba): crbug.com/251116 Support cancelling jobs not yet started.
-    if (!job->cancel_callback.is_null())
-      job->cancel_callback.Run();
+    if (job->job_info.state == STATE_RUNNING) {
+      // If the job is running an HTTP request, cancel it via |cancel_callback|
+      // returned from the request, and wait for termination in the normal
+      // callback handler, OnJobDone.
+      if (!job->cancel_callback.is_null())
+        job->cancel_callback.Run();
+    } else {
+      // Otherwise, just remove from the queue and calls back to the client.
+      base::Callback<void(google_apis::GDataErrorCode)> callback =
+          job->abort_callback;
+      queue_[GetJobQueueType(job->job_info.job_type)]->Remove(job_id);
+      job_map_.Remove(job_id);
+      callback.Run(google_apis::GDATA_CANCELLED);
+    }
   }
 }
 
 void JobScheduler::CancelAllJobs() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // CancelJob may remove the entry from |job_map_|. That's OK. IDMap supports
   // removable during iteration.
   for (JobIDMap::iterator iter(&job_map_); !iter.IsAtEnd(); iter.Advance())
     CancelJob(iter.GetCurrentKey());
 }
 
 void JobScheduler::GetAboutResource(
     const google_apis::GetAboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_ABOUT_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAboutResource,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetAboutResourceJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetAppList(
     const google_apis::GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_APP_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAppList,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetAppListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetAllResourceList(
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_ALL_RESOURCE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetAllResourceList,
       base::Unretained(drive_service_),
       base::Bind(&JobScheduler::OnGetResourceListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetResourceListInDirectory(
     const std::string& directory_resource_id,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(
       TYPE_GET_RESOURCE_LIST_IN_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetResourceListInDirectory,
       base::Unretained(drive_service_),
       directory_resource_id,
       base::Bind(&JobScheduler::OnGetResourceListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::Search(
     const std::string& search_query,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_SEARCH);
   new_job->task = base::Bind(
       &DriveServiceInterface::Search,
       base::Unretained(drive_service_),
       search_query,
       base::Bind(&JobScheduler::OnGetResourceListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetChangeList(
     int64 start_changestamp,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_CHANGE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::GetChangeList,
       base::Unretained(drive_service_),
       start_changestamp,
       base::Bind(&JobScheduler::OnGetResourceListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::ContinueGetResourceList(
     const GURL& next_url,
     const google_apis::GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_CONTINUE_GET_RESOURCE_LIST);
   new_job->task = base::Bind(
       &DriveServiceInterface::ContinueGetResourceList,
       base::Unretained(drive_service_),
       next_url,
       base::Bind(&JobScheduler::OnGetResourceListJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::GetResourceEntry(
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_GET_RESOURCE_ENTRY);
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::GetResourceEntry,
       base::Unretained(drive_service_),
       resource_id,
       base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::DeleteResource(
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_DELETE_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::DeleteResource,
       base::Unretained(drive_service_),
       resource_id,
       "",  // etag
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::CopyResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_name,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_COPY_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::CopyResource,
       base::Unretained(drive_service_),
       resource_id,
       parent_resource_id,
       new_name,
       base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::CopyHostedDocument(
     const std::string& resource_id,
     const std::string& new_name,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_COPY_HOSTED_DOCUMENT);
   new_job->task = base::Bind(
       &DriveServiceInterface::CopyHostedDocument,
       base::Unretained(drive_service_),
       resource_id,
       new_name,
       base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::RenameResource(
     const std::string& resource_id,
     const std::string& new_name,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_RENAME_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::RenameResource,
       base::Unretained(drive_service_),
       resource_id,
       new_name,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::TouchResource(
     const std::string& resource_id,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_TOUCH_RESOURCE);
   new_job->task = base::Bind(
       &DriveServiceInterface::TouchResource,
       base::Unretained(drive_service_),
       resource_id,
       modified_date,
       last_viewed_by_me_date,
       base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_RESOURCE_TO_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::AddResourceToDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       resource_id,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_REMOVE_RESOURCE_FROM_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::RemoveResourceFromDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       resource_id,
       base::Bind(&JobScheduler::OnEntryActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = callback;
   StartJob(new_job);
 }
 
 void JobScheduler::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const google_apis::GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_ADD_NEW_DIRECTORY);
   new_job->task = base::Bind(
       &DriveServiceInterface::AddNewDirectory,
       base::Unretained(drive_service_),
       parent_resource_id,
       directory_name,
       base::Bind(&JobScheduler::OnGetResourceEntryJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  callback));
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 JobID JobScheduler::DownloadFile(
     const base::FilePath& virtual_path,
     const base::FilePath& local_cache_path,
     const GURL& download_url,
     const ClientContext& context,
     const google_apis::DownloadActionCallback& download_action_callback,
     const google_apis::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* new_job = CreateNewJob(TYPE_DOWNLOAD_FILE);
   new_job->job_info.file_path = virtual_path;
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::DownloadFile,
       base::Unretained(drive_service_),
       local_cache_path,
       download_url,
       base::Bind(&JobScheduler::OnDownloadActionJobDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id,
                  download_action_callback),
       get_content_callback,
       base::Bind(&JobScheduler::UpdateProgress,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_job->job_info.job_id));
-
+  new_job->abort_callback = CreateErrorRunCallback(download_action_callback);
   StartJob(new_job);
   return new_job->job_info.job_id;
 }
 
 void JobScheduler::UploadNewFile(
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& title,
     const std::string& content_type,
@@ skipping 17 matching lines @@
 
   params.callback = base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                                weak_ptr_factory_.GetWeakPtr(),
                                new_job->job_info.job_id,
                                resume_params,
                                callback);
   params.progress_callback = base::Bind(&JobScheduler::UpdateProgress,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         new_job->job_info.job_id);
   new_job->task = base::Bind(&RunUploadNewFile, uploader_.get(), params);
-
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::UploadExistingFile(
     const std::string& resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& content_type,
     const std::string& etag,
     const ClientContext& context,
@@ skipping 16 matching lines @@
 
   params.callback = base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                                weak_ptr_factory_.GetWeakPtr(),
                                new_job->job_info.job_id,
                                resume_params,
                                callback);
   params.progress_callback = base::Bind(&JobScheduler::UpdateProgress,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         new_job->job_info.job_id);
   new_job->task = base::Bind(&RunUploadExistingFile, uploader_.get(), params);
-
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 void JobScheduler::CreateFile(
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const std::string& title,
     const std::string& content_type,
     const ClientContext& context,
     const google_apis::GetResourceEntryCallback& callback) {
@@ skipping 16 matching lines @@
   resume_params.content_type = params.content_type;
 
   params.callback = base::Bind(&JobScheduler::OnUploadCompletionJobDone,
                                weak_ptr_factory_.GetWeakPtr(),
                                new_job->job_info.job_id,
                                resume_params,
                                callback);
   params.progress_callback = google_apis::ProgressCallback();
 
   new_job->task = base::Bind(&RunUploadNewFile, uploader_.get(), params);
-
+  new_job->abort_callback = CreateErrorRunCallback(callback);
   StartJob(new_job);
 }
 
 JobScheduler::JobEntry* JobScheduler::CreateNewJob(JobType type) {
   JobEntry* job = new JobEntry(type);
   job->job_info.job_id = job_map_.Add(job);  // Takes the ownership of |job|.
   return job;
 }
 
 void JobScheduler::StartJob(JobEntry* job) {
@@ skipping 338 matching lines @@
     case FILE_QUEUE:
       return "FILE_QUEUE";
     case NUM_QUEUES:
       break;  // This value is just a sentinel. Should never be used.
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace drive