Replace PluginThreadTaskRunner with a simpler MainPluginThreadTaskRunner.

remoting/base/plugin_thread_task_runner.cc

-// 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