components/scheduler/child/webthread_base.cc

   1 // Copyright 2014 The Chromium 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 // An implementation of WebThread in terms of base::MessageLoop and
   6 // base::Thread
   7
   8 #include "components/scheduler/child/webthread_base.h"
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/pending_task.h"
  13 #include "base/threading/platform_thread.h"
  14 #include "components/scheduler/child/single_thread_idle_task_runner.h"
  15 #include "third_party/WebKit/public/platform/WebTraceLocation.h"
  16
  17 namespace scheduler {
  18
  19 class WebThreadBase::TaskObserverAdapter
  20     : public base::MessageLoop::TaskObserver {
  21  public:
  22   TaskObserverAdapter(WebThread::TaskObserver* observer)
  23       : observer_(observer) {}
  24
  25   void WillProcessTask(const base::PendingTask& pending_task) override {
  26     observer_->willProcessTask();
  27   }
  28
  29   void DidProcessTask(const base::PendingTask& pending_task) override {
  30     observer_->didProcessTask();
  31   }
  32
  33  private:
  34   WebThread::TaskObserver* observer_;
  35 };
  36
  37 WebThreadBase::WebThreadBase() {
  38 }
  39
  40 WebThreadBase::~WebThreadBase() {
  41   for (auto& observer_entry : task_observer_map_) {
  42     delete observer_entry.second;
  43   }
  44 }
  45
  46 void WebThreadBase::addTaskObserver(TaskObserver* observer) {
  47   CHECK(isCurrentThread());
  48   std::pair<TaskObserverMap::iterator, bool> result = task_observer_map_.insert(
  49       std::make_pair(observer, static_cast<TaskObserverAdapter*>(NULL)));
  50   if (result.second)
  51     result.first->second = new TaskObserverAdapter(observer);
  52   AddTaskObserverInternal(result.first->second);
  53 }
  54
  55 void WebThreadBase::removeTaskObserver(TaskObserver* observer) {
  56   CHECK(isCurrentThread());
  57   TaskObserverMap::iterator iter = task_observer_map_.find(observer);
  58   if (iter == task_observer_map_.end())
  59     return;
  60   RemoveTaskObserverInternal(iter->second);
  61   delete iter->second;
  62   task_observer_map_.erase(iter);
  63 }
  64
  65 void WebThreadBase::AddTaskObserverInternal(
  66     base::MessageLoop::TaskObserver* observer) {
  67   base::MessageLoop::current()->AddTaskObserver(observer);
  68 }
  69
  70 void WebThreadBase::RemoveTaskObserverInternal(
  71     base::MessageLoop::TaskObserver* observer) {
  72   base::MessageLoop::current()->RemoveTaskObserver(observer);
  73 }
  74
  75 // static
  76 void WebThreadBase::RunWebThreadIdleTask(
  77     scoped_ptr<blink::WebThread::IdleTask> idle_task,
  78     base::TimeTicks deadline) {
  79   idle_task->run((deadline - base::TimeTicks()).InSecondsF());
  80 }
  81
  82 void WebThreadBase::postIdleTask(const blink::WebTraceLocation& web_location,
  83                                  IdleTask* idle_task) {
  84   tracked_objects::Location location(web_location.functionName(),
  85                                      web_location.fileName(), -1, nullptr);
  86   IdleTaskRunner()->PostIdleTask(
  87       location, base::Bind(&WebThreadBase::RunWebThreadIdleTask,
  88                            base::Passed(make_scoped_ptr(idle_task))));
  89 }
  90
  91 void WebThreadBase::postIdleTaskAfterWakeup(
  92     const blink::WebTraceLocation& web_location,
  93     IdleTask* idle_task) {
  94   tracked_objects::Location location(web_location.functionName(),
  95                                      web_location.fileName(), -1, nullptr);
  96   IdleTaskRunner()->PostIdleTaskAfterWakeup(
  97       location, base::Bind(&WebThreadBase::RunWebThreadIdleTask,
  98                            base::Passed(make_scoped_ptr(idle_task))));
  99 }
 100
 101 bool WebThreadBase::isCurrentThread() const {
 102   return TaskRunner()->BelongsToCurrentThread();
 103 }
 104
 105 }  // namespace scheduler