drive: Return cancel closure from FileSystem::GetFileContent

chrome/browser/chromeos/drive/sync_client.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/sync_client.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 109 matching lines @@
     if (error != FILE_ERROR_OK) {
       LOG(WARNING) << "Failed to pin cache entry: " << local_id;
       continue;
     }
 
     local_ids->push_back(local_id);
   }
   DCHECK(!it->HasError());
 }
 
+// Runs the task and returns a dummy cancel closure.
+base::Closure RunTaskAndReturnDummyCancelClosure(const base::Closure& task) {
+  task.Run();
+  return base::Closure();
+}
+
 }  // namespace
 
 SyncClient::SyncTask::SyncTask() : state(PENDING), should_run_again(false) {}
 SyncClient::SyncTask::~SyncTask() {}
 
 SyncClient::SyncClient(base::SequencedTaskRunner* blocking_task_runner,
                        file_system::OperationObserver* observer,
                        JobScheduler* scheduler,
                        ResourceMetadata* metadata,
                        FileCache* cache,
@@ skipping 88 matching lines @@
 void SyncClient::AddFetchTaskInternal(const std::string& local_id,
                                       const base::TimeDelta& delay) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SyncTask task;
   task.task = base::Bind(
       &file_system::DownloadOperation::EnsureFileDownloadedByLocalId,
       base::Unretained(download_operation_.get()),
       local_id,
       ClientContext(BACKGROUND),
-      base::Bind(&SyncClient::OnGetFileContentInitialized,
-                 weak_ptr_factory_.GetWeakPtr()),
+      GetFileContentInitializedCallback(),
       google_apis::GetContentCallback(),
       base::Bind(&SyncClient::OnFetchFileComplete,
                  weak_ptr_factory_.GetWeakPtr(),
                  local_id));
   AddTask(SyncTasks::key_type(FETCH, local_id), task, delay);
 }
 
 void SyncClient::AddUpdateTaskInternal(const ClientContext& context,
                                        const std::string& local_id,
                                        const base::TimeDelta& delay) {
   SyncTask task;
   task.task = base::Bind(
-      &EntryUpdatePerformer::UpdateEntry,
-      base::Unretained(entry_update_performer_.get()),
-      local_id,
-      context,
-      base::Bind(&SyncClient::OnUpdateComplete,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 local_id));
+      &RunTaskAndReturnDummyCancelClosure,
+      base::Bind(&EntryUpdatePerformer::UpdateEntry,
+                 base::Unretained(entry_update_performer_.get()),
+                 local_id,
+                 context,
+                 base::Bind(&SyncClient::OnUpdateComplete,
+                            weak_ptr_factory_.GetWeakPtr(),
+                            local_id)));
   AddTask(SyncTasks::key_type(UPDATE, local_id), task, delay);
 }
 
 void SyncClient::AddTask(const SyncTasks::key_type& key,
                          const SyncTask& task,
                          const base::TimeDelta& delay) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SyncTasks::iterator it = tasks_.find(key);
   if (it != tasks_.end()) {
@@ skipping 20 matching lines @@
 
 void SyncClient::StartTask(const SyncTasks::key_type& key) {
   SyncTasks::iterator it = tasks_.find(key);
   if (it == tasks_.end())
     return;
 
   SyncTask* task = &it->second;
   switch (task->state) {
     case PENDING:
       task->state = RUNNING;
-      task->task.Run();
+      task->cancel_closure = task->task.Run();
       break;
     case RUNNING:  // Do nothing.
       break;
   }
 }
 
 void SyncClient::OnGetLocalIdsOfBacklog(
     const std::vector<std::string>* to_fetch,
     const std::vector<std::string>* to_update) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 13 matching lines @@
   }
 }
 
 void SyncClient::AddFetchTasks(const std::vector<std::string>* local_ids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < local_ids->size(); ++i)
     AddFetchTask((*local_ids)[i]);
 }
 
-void SyncClient::OnGetFileContentInitialized(
-    FileError error,
-    scoped_ptr<ResourceEntry> entry,
-    const base::FilePath& local_cache_file_path,
-    const base::Closure& cancel_download_closure) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (error != FILE_ERROR_OK)
-    return;
-
-  const SyncTasks::key_type key(FETCH, entry->local_id());
-  SyncTasks::iterator it = tasks_.find(key);
-  DCHECK(it != tasks_.end());
-
-  it->second.cancel_closure = cancel_download_closure;
-}
-
 bool SyncClient::OnTaskComplete(SyncType type, const std::string& local_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const SyncTasks::key_type key(type, local_id);
   SyncTasks::iterator it = tasks_.find(key);
   DCHECK(it != tasks_.end());
 
   if (it->second.should_run_again) {
     DVLOG(1) << "Running again: type = " << type << ", id = " << local_id;
     it->second.should_run_again = false;
@@ skipping 104 matching lines @@
     const ResourceEntry& entry = (*entries)[i];
     if (entry.metadata_edit_state() != ResourceEntry::CLEAN) {
       AddUpdateTaskInternal(ClientContext(BACKGROUND), entry.local_id(),
                             base::TimeDelta::FromSeconds(0));
     }
   }
 }
 
 }  // namespace internal
 }  // namespace drive