Index: remoting/base/plugin_thread_task_runner.cc |
diff --git a/remoting/base/plugin_thread_task_runner.cc b/remoting/base/plugin_thread_task_runner.cc |
deleted file mode 100644 |
index 0a7c8e1e98087db849ff7613e0129bc7d0a0e92a..0000000000000000000000000000000000000000 |
--- a/remoting/base/plugin_thread_task_runner.cc |
+++ /dev/null |
@@ -1,247 +0,0 @@ |
-// 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 "remoting/base/plugin_thread_task_runner.h" |
- |
-#include "base/bind.h" |
- |
-namespace { |
- |
-base::TimeDelta CalcTimeDelta(base::TimeTicks when) { |
- return std::max(when - base::TimeTicks::Now(), base::TimeDelta()); |
-} |
- |
-} // namespace |
- |
-namespace remoting { |
- |
-PluginThreadTaskRunner::Delegate::~Delegate() { |
-} |
- |
-PluginThreadTaskRunner::PluginThreadTaskRunner(Delegate* delegate) |
- : plugin_thread_id_(base::PlatformThread::CurrentId()), |
- event_(false, false), |
- delegate_(delegate), |
- next_sequence_num_(0), |
- quit_received_(false), |
- stopped_(false) { |
-} |
- |
-PluginThreadTaskRunner::~PluginThreadTaskRunner() { |
- DCHECK(delegate_ == NULL); |
- DCHECK(stopped_); |
-} |
- |
-void PluginThreadTaskRunner::DetachAndRunShutdownLoop() { |
- DCHECK(BelongsToCurrentThread()); |
- |
- // Detach from the plugin thread and redirect all tasks posted after this |
- // point to the shutdown task loop. |
- { |
- base::AutoLock auto_lock(lock_); |
- |
- DCHECK(delegate_ != NULL); |
- DCHECK(!stopped_); |
- |
- delegate_ = NULL; |
- stopped_ = quit_received_; |
- } |
- |
- // When DetachAndRunShutdownLoop() is called from NPP_Destroy() all scheduled |
- // timers are cancelled. It is OK to clear |scheduled_timers_| even if |
- // the timers weren't actually cancelled (i.e. DetachAndRunShutdownLoop() is |
- // called before NPP_Destroy()). |
- scheduled_timers_.clear(); |
- |
- // Run all tasks that are due. |
- ProcessIncomingTasks(); |
- RunDueTasks(base::TimeTicks::Now()); |
- |
- while (!stopped_) { |
- if (delayed_queue_.empty()) { |
- event_.Wait(); |
- } else { |
- event_.TimedWait(CalcTimeDelta(delayed_queue_.top().delayed_run_time)); |
- } |
- |
- // Run all tasks that are due. |
- ProcessIncomingTasks(); |
- RunDueTasks(base::TimeTicks::Now()); |
- |
- base::AutoLock auto_lock(lock_); |
- stopped_ = quit_received_; |
- } |
-} |
- |
-void PluginThreadTaskRunner::Quit() { |
- base::AutoLock auto_lock(lock_); |
- |
- if (!quit_received_) { |
- quit_received_ = true; |
- event_.Signal(); |
- } |
-} |
- |
-bool PluginThreadTaskRunner::PostDelayedTask( |
- const tracked_objects::Location& from_here, |
- const base::Closure& task, |
- base::TimeDelta delay) { |
- |
- // Wrap the task into |base::PendingTask|. |
- base::TimeTicks delayed_run_time; |
- if (delay > base::TimeDelta()) { |
- delayed_run_time = base::TimeTicks::Now() + delay; |
- } else { |
- DCHECK_EQ(delay.InMilliseconds(), 0) << "delay should not be negative"; |
- } |
- |
- base::PendingTask pending_task(from_here, task, delayed_run_time, false); |
- |
- // Push the task to the incoming queue. |
- base::AutoLock locked(lock_); |
- |
- // Initialize the sequence number. The sequence number provides FIFO ordering |
- // for tasks with the same |delayed_run_time|. |
- pending_task.sequence_num = next_sequence_num_++; |
- |
- // Post an asynchronous call on the plugin thread to process the task. |
- if (incoming_queue_.empty()) { |
- PostRunTasks(); |
- } |
- |
- incoming_queue_.push(pending_task); |
- pending_task.task.Reset(); |
- |
- // No tasks should be posted after Quit() has been called. |
- DCHECK(!quit_received_); |
- return true; |
-} |
- |
-bool PluginThreadTaskRunner::PostNonNestableDelayedTask( |
- const tracked_objects::Location& from_here, |
- const base::Closure& task, |
- base::TimeDelta delay) { |
- // All tasks running on this task loop are non-nestable. |
- return PostDelayedTask(from_here, task, delay); |
-} |
- |
-bool PluginThreadTaskRunner::RunsTasksOnCurrentThread() const { |
- // In pepper plugins ideally we should use pp::Core::IsMainThread, |
- // but it is problematic because we would need to keep reference to |
- // Core somewhere, e.g. make the delegate ref-counted. |
- return base::PlatformThread::CurrentId() == plugin_thread_id_; |
-} |
- |
-void PluginThreadTaskRunner::PostRunTasks() { |
- // Post tasks to the plugin thread when it is availabe or spin the shutdown |
- // task loop. |
- if (delegate_ != NULL) { |
- base::Closure closure = base::Bind(&PluginThreadTaskRunner::RunTasks, this); |
- delegate_->RunOnPluginThread( |
- base::TimeDelta(), |
- &PluginThreadTaskRunner::TaskSpringboard, |
- new base::Closure(closure)); |
- } else { |
- event_.Signal(); |
- } |
-} |
- |
-void PluginThreadTaskRunner::PostDelayedRunTasks(base::TimeTicks when) { |
- DCHECK(BelongsToCurrentThread()); |
- |
- // |delegate_| is updated from the plugin thread only, so it is safe to access |
- // it here without taking the lock. |
- if (delegate_ != NULL) { |
- // Schedule RunDelayedTasks() to be called at |when| if it hasn't been |
- // scheduled already. |
- if (scheduled_timers_.insert(when).second) { |
- base::TimeDelta delay = CalcTimeDelta(when); |
- base::Closure closure = |
- base::Bind(&PluginThreadTaskRunner::RunDelayedTasks, this, when); |
- delegate_->RunOnPluginThread( |
- delay, |
- &PluginThreadTaskRunner::TaskSpringboard, |
- new base::Closure(closure)); |
- } |
- } else { |
- // Spin the shutdown loop if the task runner has already been detached. |
- // The shutdown loop will pick the tasks to run itself. |
- event_.Signal(); |
- } |
-} |
- |
-void PluginThreadTaskRunner::ProcessIncomingTasks() { |
- DCHECK(BelongsToCurrentThread()); |
- |
- // Grab all unsorted tasks accomulated so far. |
- base::TaskQueue work_queue; |
- { |
- base::AutoLock locked(lock_); |
- incoming_queue_.Swap(&work_queue); |
- } |
- |
- while (!work_queue.empty()) { |
- base::PendingTask pending_task = work_queue.front(); |
- work_queue.pop(); |
- |
- if (pending_task.delayed_run_time.is_null()) { |
- pending_task.task.Run(); |
- } else { |
- delayed_queue_.push(pending_task); |
- } |
- } |
-} |
- |
-void PluginThreadTaskRunner::RunDelayedTasks(base::TimeTicks when) { |
- DCHECK(BelongsToCurrentThread()); |
- |
- scheduled_timers_.erase(when); |
- |
- // |stopped_| is updated by the plugin thread only, so it is safe to access |
- // it here without taking the lock. |
- if (!stopped_) { |
- ProcessIncomingTasks(); |
- RunDueTasks(base::TimeTicks::Now()); |
- } |
-} |
- |
-void PluginThreadTaskRunner::RunDueTasks(base::TimeTicks now) { |
- DCHECK(BelongsToCurrentThread()); |
- |
- // Run all due tasks. |
- while (!delayed_queue_.empty() && |
- delayed_queue_.top().delayed_run_time <= now) { |
- delayed_queue_.top().task.Run(); |
- delayed_queue_.pop(); |
- } |
- |
- // Post a delayed asynchronous call to the plugin thread to process tasks from |
- // the delayed queue. |
- if (!delayed_queue_.empty()) { |
- base::TimeTicks when = delayed_queue_.top().delayed_run_time; |
- if (scheduled_timers_.empty() || when < *scheduled_timers_.begin()) { |
- PostDelayedRunTasks(when); |
- } |
- } |
-} |
- |
-void PluginThreadTaskRunner::RunTasks() { |
- DCHECK(BelongsToCurrentThread()); |
- |
- // |stopped_| is updated by the plugin thread only, so it is safe to access |
- // it here without taking the lock. |
- if (!stopped_) { |
- ProcessIncomingTasks(); |
- RunDueTasks(base::TimeTicks::Now()); |
- } |
-} |
- |
-// static |
-void PluginThreadTaskRunner::TaskSpringboard(void* data) { |
- base::Closure* task = reinterpret_cast<base::Closure*>(data); |
- task->Run(); |
- delete task; |
-} |
- |
-} // namespace remoting |