Home | History | Annotate | Download | only in src 
      1 // Copyright 2015 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "src/cancelable-task.h"
      6 
      7 #include "src/base/platform/platform.h"
      8 #include "src/isolate.h"
      9 
     10 namespace v8 {
     11 namespace internal {
     12 
     13 
     14 Cancelable::Cancelable(CancelableTaskManager* parent)
     15     : parent_(parent), status_(kWaiting), id_(0), cancel_counter_(0) {
     16   id_ = parent->Register(this);
     17 }
     18 
     19 
     20 Cancelable::~Cancelable() {
     21   // The following check is needed to avoid calling an already terminated
     22   // manager object. This happens when the manager cancels all pending tasks
     23   // in {CancelAndWait} only before destroying the manager object.
     24   if (TryRun() || IsRunning()) {
     25     parent_->RemoveFinishedTask(id_);
     26   }
     27 }
     28 
     29 CancelableTaskManager::CancelableTaskManager()
     30     : task_id_counter_(0), canceled_(false) {}
     31 
     32 uint32_t CancelableTaskManager::Register(Cancelable* task) {
     33   base::LockGuard<base::Mutex> guard(&mutex_);
     34   uint32_t id = ++task_id_counter_;
     35   // The loop below is just used when task_id_counter_ overflows.
     36   while (cancelable_tasks_.count(id) > 0) ++id;
     37   CHECK(!canceled_);
     38   cancelable_tasks_[id] = task;
     39   return id;
     40 }
     41 
     42 
     43 void CancelableTaskManager::RemoveFinishedTask(uint32_t id) {
     44   base::LockGuard<base::Mutex> guard(&mutex_);
     45   size_t removed = cancelable_tasks_.erase(id);
     46   USE(removed);
     47   DCHECK_NE(0u, removed);
     48   cancelable_tasks_barrier_.NotifyOne();
     49 }
     50 
     51 CancelableTaskManager::TryAbortResult CancelableTaskManager::TryAbort(
     52     uint32_t id) {
     53   base::LockGuard<base::Mutex> guard(&mutex_);
     54   auto entry = cancelable_tasks_.find(id);
     55   if (entry != cancelable_tasks_.end()) {
     56     Cancelable* value = entry->second;
     57     if (value->Cancel()) {
     58       // Cannot call RemoveFinishedTask here because of recursive locking.
     59       cancelable_tasks_.erase(entry);
     60       cancelable_tasks_barrier_.NotifyOne();
     61       return kTaskAborted;
     62     } else {
     63       return kTaskRunning;
     64     }
     65   }
     66   return kTaskRemoved;
     67 }
     68 
     69 
     70 void CancelableTaskManager::CancelAndWait() {
     71   // Clean up all cancelable fore- and background tasks. Tasks are canceled on
     72   // the way if possible, i.e., if they have not started yet.  After each round
     73   // of canceling we wait for the background tasks that have already been
     74   // started.
     75   base::LockGuard<base::Mutex> guard(&mutex_);
     76   canceled_ = true;
     77 
     78   // Cancelable tasks could be running or could potentially register new
     79   // tasks, requiring a loop here.
     80   while (!cancelable_tasks_.empty()) {
     81     for (auto it = cancelable_tasks_.begin(); it != cancelable_tasks_.end();) {
     82       auto current = it;
     83       // We need to get to the next element before erasing the current.
     84       ++it;
     85       if (current->second->Cancel()) {
     86         cancelable_tasks_.erase(current);
     87       }
     88     }
     89     // Wait for already running background tasks.
     90     if (!cancelable_tasks_.empty()) {
     91       cancelable_tasks_barrier_.Wait(&mutex_);
     92     }
     93   }
     94 }
     95 
     96 CancelableTaskManager::TryAbortResult CancelableTaskManager::TryAbortAll() {
     97   // Clean up all cancelable fore- and background tasks. Tasks are canceled on
     98   // the way if possible, i.e., if they have not started yet.
     99   base::LockGuard<base::Mutex> guard(&mutex_);
    100 
    101   if (cancelable_tasks_.empty()) return kTaskRemoved;
    102 
    103   for (auto it = cancelable_tasks_.begin(); it != cancelable_tasks_.end();) {
    104     if (it->second->Cancel()) {
    105       it = cancelable_tasks_.erase(it);
    106     } else {
    107       ++it;
    108     }
    109   }
    110 
    111   return cancelable_tasks_.empty() ? kTaskAborted : kTaskRunning;
    112 }
    113 
    114 CancelableTask::CancelableTask(Isolate* isolate)
    115     : CancelableTask(isolate, isolate->cancelable_task_manager()) {}
    116 
    117 CancelableTask::CancelableTask(Isolate* isolate, CancelableTaskManager* manager)
    118     : Cancelable(manager), isolate_(isolate) {}
    119 
    120 CancelableIdleTask::CancelableIdleTask(Isolate* isolate)
    121     : CancelableIdleTask(isolate, isolate->cancelable_task_manager()) {}
    122 
    123 CancelableIdleTask::CancelableIdleTask(Isolate* isolate,
    124                                        CancelableTaskManager* manager)
    125     : Cancelable(manager), isolate_(isolate) {}
    126 
    127 }  // namespace internal
    128 }  // namespace v8
    129