Reland of Change the update_client task runner behavior to continue on shutdown.

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 50 matching lines @@
 // pointer to itself. Otherwise, a life time circular dependency between this
 // instance and its inner members prevents the destruction of this instance.
 // Using unretained references is allowed in this case since the life time of
 // the UpdateClient instance exceeds the life time of its inner members,
 // including any thread objects that might execute callbacks bound to it.
 UpdateClientImpl::UpdateClientImpl(
     const scoped_refptr<Configurator>& config,
     scoped_ptr<PingManager> ping_manager,
     UpdateChecker::Factory update_checker_factory,
     CrxDownloader::Factory crx_downloader_factory)
-    : config_(config),
+    : is_stopped_(false),
+      config_(config),
       ping_manager_(ping_manager.Pass()),
       update_engine_(
           new UpdateEngine(config,
                            update_checker_factory,
                            crx_downloader_factory,
                            ping_manager_.get(),
                            base::Bind(&UpdateClientImpl::NotifyObservers,
-                                      base::Unretained(this)))) {
-}
+                                      base::Unretained(this)))) {}
 
 UpdateClientImpl::~UpdateClientImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  while (!task_queue_.empty()) {
-    delete task_queue_.front();
-    task_queue_.pop();
-  }
+  DCHECK(task_queue_.empty());
+  DCHECK(tasks_.empty());
 
   config_ = nullptr;
 }
 
 void UpdateClientImpl::Install(const std::string& id,
                                const CrxDataCallback& crx_data_callback,
                                const CompletionCallback& completion_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (IsUpdating(id)) {
@@ skipping 44 matching lines @@
 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));
 
+  // Remove the task from the set of the running tasks. Only tasks handled by
+  // the update engine can be in this data structure.
   tasks_.erase(task);
+
+  // Delete the completed task. A task can be completed because the update
+  // engine has run it or because it has been canceled but never run.
   delete task;
 
+  if (is_stopped_)
+    return;
+
   // 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(scoped_ptr<Task>(task_queue_.front()).Pass());
     task_queue_.pop();
   }
 }
 
 void UpdateClientImpl::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 22 matching lines @@
   for (const auto& task : tasks_) {
     const auto ids(task->GetIds());
     if (std::find(ids.begin(), ids.end(), id) != ids.end()) {
       return true;
     }
   }
 
   return false;
 }
 
+void UpdateClientImpl::Stop() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  is_stopped_ = true;
+
+  // In the current implementation it is sufficient to cancel the pending
+  // tasks only. The tasks that are run by the update engine will stop
+  // making progress naturally, as the main task runner stops running task
+  // actions. Upon the browser shutdown, the resources employed by the active
+  // tasks will leak, as the operating system kills the thread associated with
+  // the update engine task runner. Further refactoring may be needed in this
+  // area, to cancel the running tasks by canceling the current action update.
+  // This behavior would be expected, correct, and result in no resource leaks
+  // in all cases, in shutdown or not.
+  //
+  // Cancel the pending tasks. These tasks are safe to cancel and delete since
+  // they have not picked up by the update engine, and not shared with any
+  // task runner yet.
+  while (!task_queue_.empty()) {
+    const auto task(task_queue_.front());
+    task_queue_.pop();
+    task->Cancel();
+  }
+}
+
 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