Fix task concurrency in components/update_client

components/update_client/update_client.cc

 // Copyright 2014 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 "components/update_client/update_client.h"
 
 #include <algorithm>
 #include <queue>
 #include <set>
 #include <utility>
@@ skipping 71 matching lines @@
 UpdateClientImpl::~UpdateClientImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   config_ = nullptr;
 }
 
 void UpdateClientImpl::Install(const std::string& id,
                                const CrxDataCallback& crx_data_callback,
                                const CompletionCallback& completion_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (update_engine_->IsUpdating(id)) {
+  if (IsUpdating(id)) {
     completion_callback.Run(Error::ERROR_UPDATE_IN_PROGRESS);
     return;
   }
 
   std::vector<std::string> ids;
   ids.push_back(id);
 
   // Partially applies |completion_callback| to OnTaskComplete, so this
   // argument is available when the task completes, along with the task itself.
   const auto callback =
       base::Bind(&UpdateClientImpl::OnTaskComplete, this, completion_callback);
   scoped_ptr<TaskUpdate> task(new TaskUpdate(update_engine_.get(), true, ids,
                                              crx_data_callback, callback));
 
+  // Install tasks are run concurrently and never queued up.
   auto it = tasks_.insert(task.release()).first;
   RunTask(*it);
 }
 
 void UpdateClientImpl::Update(const std::vector<std::string>& ids,
                               const CrxDataCallback& crx_data_callback,
                               const CompletionCallback& completion_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const auto callback =
       base::Bind(&UpdateClientImpl::OnTaskComplete, this, completion_callback);
   scoped_ptr<TaskUpdate> task(new TaskUpdate(update_engine_.get(), false, ids,
                                              crx_data_callback, callback));
 
+  // If no other tasks are running at the moment, run this update task.
+  // Otherwise, queue the task up.
   if (tasks_.empty()) {
     auto it = tasks_.insert(task.release()).first;
     RunTask(*it);
   } else {
     task_queue_.push(task.release());
   }
 }
 
 void UpdateClientImpl::RunTask(Task* task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&Task::Run, base::Unretained(task)));
 }
 
 void UpdateClientImpl::OnTaskComplete(
     const CompletionCallback& completion_callback,
     Task* task,
     int error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(task);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(completion_callback, error));
 
   tasks_.erase(task);
   delete task;
 
-  if (!task_queue_.empty()) {
+  // Pick up a task from the queue if the queue has pending tasks and no other
+  // task is running.
+  if (tasks_.empty() && !task_queue_.empty()) {
     RunTask(task_queue_.front());
     task_queue_.pop();
   }
 }
 
 void UpdateClientImpl::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.AddObserver(observer);
 }
 
 void UpdateClientImpl::RemoveObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.RemoveObserver(observer);
 }
 
 void UpdateClientImpl::NotifyObservers(Observer::Events event,
                                        const std::string& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(Observer, observer_list_, OnEvent(event, id));
 }
 
 bool UpdateClientImpl::GetCrxUpdateState(const std::string& id,
                                          CrxUpdateItem* update_item) const {
   return update_engine_->GetUpdateState(id, update_item);
 }
 
 bool UpdateClientImpl::IsUpdating(const std::string& id) const {
-  return update_engine_->IsUpdating(id);
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  for (const auto& task : tasks_) {
+    const auto ids(task->GetIds());
+    if (std::find(std::begin(ids), std::end(ids), id) != std::end(ids)) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 scoped_refptr<UpdateClient> UpdateClientFactory(
     const scoped_refptr<Configurator>& config) {
   scoped_ptr<PingManager> ping_manager(new PingManager(*config));
   return new UpdateClientImpl(config, ping_manager.Pass(),
                               &UpdateChecker::Create, &CrxDownloader::Create);
 }
 
 }  // namespace update_client