Fix protocol for aborting and waiting for cancelable tasks.

src/cancelable-task.cc

 // Copyright 2015 the V8 project 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 "src/cancelable-task.h"
 
 #include "src/base/platform/platform.h"
 #include "src/isolate.h"
 
 namespace v8 {
 namespace internal {
 
 
 Cancelable::Cancelable(CancelableTaskManager* parent)
     : parent_(parent), status_(kWaiting), id_(0), cancel_counter_(0) {
   id_ = parent->Register(this);
   CHECK(id_ != 0);
 }
 
 
 Cancelable::~Cancelable() {
   // The following check is needed to avoid calling an already terminated
   // manager object. This happens when the manager cancels all pending tasks
   // in {CancelAndWait} only before destroying the manager object.
   if (TryRun() || IsRunning()) {
-    parent_->TryAbort(id_);
+    parent_->RemoveFinishedTask(id_);
   }
 }
 
 
 static bool ComparePointers(void* ptr1, void* ptr2) { return ptr1 == ptr2; }
 
 
 CancelableTaskManager::CancelableTaskManager()
     : task_id_counter_(0), cancelable_tasks_(ComparePointers) {}
 
 
 uint32_t CancelableTaskManager::Register(Cancelable* task) {
   base::LockGuard<base::Mutex> guard(&mutex_);
   uint32_t id = ++task_id_counter_;
   // The loop below is just used when task_id_counter_ overflows.
   while ((id == 0) || (cancelable_tasks_.Lookup(reinterpret_cast<void*>(id),
                                                 id) != nullptr)) {
     ++id;
   }
   HashMap::Entry* entry =
       cancelable_tasks_.LookupOrInsert(reinterpret_cast<void*>(id), id);
   entry->value = task;
   return id;
 }
 
 
+void CancelableTaskManager::RemoveFinishedTask(uint32_t id) {
+  base::LockGuard<base::Mutex> guard(&mutex_);
+  void* removed = cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id);
+  USE(removed);
+  DCHECK(removed != nullptr);
+  cancelable_tasks_barrier_.NotifyOne();
+}
+
+
 bool CancelableTaskManager::TryAbort(uint32_t id) {
   base::LockGuard<base::Mutex> guard(&mutex_);
-  Cancelable* value = reinterpret_cast<Cancelable*>(
-      cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id));
-  if (value != nullptr) {
-    bool success = value->Cancel();
-    cancelable_tasks_barrier_.NotifyOne();
-    if (!success) return false;
-    return true;
+  HashMap::Entry* entry =
+      cancelable_tasks_.Lookup(reinterpret_cast<void*>(id), id);
+  if (entry != nullptr) {
+    Cancelable* value = reinterpret_cast<Cancelable*>(entry->value);
+    if (value->Cancel()) {
+      // Cannot call RemoveFinishedTask here because of recursive locking.
+      void* removed = cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id);
+      USE(removed);
+      DCHECK(removed != nullptr);
+      cancelable_tasks_barrier_.NotifyOne();
+      return true;
+    }
   }
   return false;
 }
 
 
 void CancelableTaskManager::CancelAndWait() {
   // Clean up all cancelable fore- and background tasks. Tasks are canceled on
   // the way if possible, i.e., if they have not started yet.  After each round
   // of canceling we wait for the background tasks that have already been
   // started.
@@ skipping 28 matching lines @@
 
 CancelableTask::CancelableTask(Isolate* isolate)
     : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {}
 
 
 CancelableIdleTask::CancelableIdleTask(Isolate* isolate)
     : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {}
 
 }  // namespace internal
 }  // namespace v8