content/child/webthread_impl.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 "content/child/webthread_impl.h"
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/pending_task.h"
  14 #include "base/threading/platform_thread.h"
  15
  16 namespace content {
  17
  18 WebThreadBase::WebThreadBase() {}
  19 WebThreadBase::~WebThreadBase() {}
  20
  21 class WebThreadBase::TaskObserverAdapter
  22     : public base::MessageLoop::TaskObserver {
  23  public:
  24   TaskObserverAdapter(WebThread::TaskObserver* observer)
  25       : observer_(observer) {}
  26
  27   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
  28     observer_->willProcessTask();
  29   }
  30
  31   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
  32     observer_->didProcessTask();
  33   }
  34
  35 private:
  36   WebThread::TaskObserver* observer_;
  37 };
  38
  39 void WebThreadBase::addTaskObserver(TaskObserver* observer) {
  40   CHECK(isCurrentThread());
  41   std::pair<TaskObserverMap::iterator, bool> result = task_observer_map_.insert(
  42       std::make_pair(observer, static_cast<TaskObserverAdapter*>(NULL)));
  43   if (result.second)
  44     result.first->second = new TaskObserverAdapter(observer);
  45   base::MessageLoop::current()->AddTaskObserver(result.first->second);
  46 }
  47
  48 void WebThreadBase::removeTaskObserver(TaskObserver* observer) {
  49   CHECK(isCurrentThread());
  50   TaskObserverMap::iterator iter = task_observer_map_.find(observer);
  51   if (iter == task_observer_map_.end())
  52     return;
  53   base::MessageLoop::current()->RemoveTaskObserver(iter->second);
  54   delete iter->second;
  55   task_observer_map_.erase(iter);
  56 }
  57
  58 WebThreadImpl::WebThreadImpl(const char* name)
  59     : thread_(new base::Thread(name)) {
  60   thread_->Start();
  61 }
  62
  63 void WebThreadImpl::postTask(Task* task) {
  64   thread_->message_loop()->PostTask(
  65       FROM_HERE, base::Bind(&blink::WebThread::Task::run, base::Owned(task)));
  66 }
  67
  68 void WebThreadImpl::postDelayedTask(Task* task, long long delay_ms) {
  69   thread_->message_loop()->PostDelayedTask(
  70       FROM_HERE,
  71       base::Bind(&blink::WebThread::Task::run, base::Owned(task)),
  72       base::TimeDelta::FromMilliseconds(delay_ms));
  73 }
  74
  75 void WebThreadImpl::enterRunLoop() {
  76   CHECK(isCurrentThread());
  77   CHECK(!thread_->message_loop()->is_running());  // We don't support nesting.
  78   thread_->message_loop()->Run();
  79 }
  80
  81 void WebThreadImpl::exitRunLoop() {
  82   CHECK(isCurrentThread());
  83   CHECK(thread_->message_loop()->is_running());
  84   thread_->message_loop()->Quit();
  85 }
  86
  87 bool WebThreadImpl::isCurrentThread() const {
  88   return thread_->thread_id() == base::PlatformThread::CurrentId();
  89 }
  90
  91 blink::PlatformThreadId WebThreadImpl::threadId() const {
  92   return thread_->thread_id();
  93 }
  94
  95 WebThreadImpl::~WebThreadImpl() {
  96   thread_->Stop();
  97 }
  98
  99 WebThreadImplForMessageLoop::WebThreadImplForMessageLoop(
 100     base::MessageLoopProxy* message_loop)
 101     : message_loop_(message_loop),
 102       thread_id_(base::PlatformThread::CurrentId()) {}
 103
 104 void WebThreadImplForMessageLoop::postTask(Task* task) {
 105   message_loop_->PostTask(
 106       FROM_HERE, base::Bind(&blink::WebThread::Task::run, base::Owned(task)));
 107 }
 108
 109 void WebThreadImplForMessageLoop::postDelayedTask(Task* task,
 110                                                   long long delay_ms) {
 111   message_loop_->PostDelayedTask(
 112       FROM_HERE,
 113       base::Bind(&blink::WebThread::Task::run, base::Owned(task)),
 114       base::TimeDelta::FromMilliseconds(delay_ms));
 115 }
 116
 117 void WebThreadImplForMessageLoop::enterRunLoop() {
 118   CHECK(isCurrentThread());
 119   // We don't support nesting.
 120   CHECK(!base::MessageLoop::current()->is_running());
 121   base::MessageLoop::current()->Run();
 122 }
 123
 124 void WebThreadImplForMessageLoop::exitRunLoop() {
 125   CHECK(isCurrentThread());
 126   CHECK(base::MessageLoop::current()->is_running());
 127   base::MessageLoop::current()->Quit();
 128 }
 129
 130 bool WebThreadImplForMessageLoop::isCurrentThread() const {
 131   return message_loop_->BelongsToCurrentThread();
 132 }
 133
 134 blink::PlatformThreadId WebThreadImplForMessageLoop::threadId() const {
 135   return thread_id_;
 136 }
 137
 138 WebThreadImplForMessageLoop::~WebThreadImplForMessageLoop() {}
 139
 140 }  // namespace content