OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h" | 5 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/location.h" | 8 #include "base/location.h" |
9 #include "base/single_thread_task_runner.h" | 9 #include "base/single_thread_task_runner.h" |
10 #include "base/synchronization/waitable_event.h" | 10 #include "base/synchronization/waitable_event.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 const char* name) | 22 const char* name) |
23 : WebThreadImplForWorkerScheduler(name, base::Thread::Options()) {} | 23 : WebThreadImplForWorkerScheduler(name, base::Thread::Options()) {} |
24 | 24 |
25 WebThreadImplForWorkerScheduler::WebThreadImplForWorkerScheduler( | 25 WebThreadImplForWorkerScheduler::WebThreadImplForWorkerScheduler( |
26 const char* name, | 26 const char* name, |
27 base::Thread::Options options) | 27 base::Thread::Options options) |
28 : thread_(new base::Thread(name ? name : std::string())) { | 28 : thread_(new base::Thread(name ? name : std::string())) { |
29 bool started = thread_->StartWithOptions(options); | 29 bool started = thread_->StartWithOptions(options); |
30 CHECK(started); | 30 CHECK(started); |
31 thread_task_runner_ = thread_->task_runner(); | 31 thread_task_runner_ = thread_->task_runner(); |
| 32 } |
32 | 33 |
| 34 void WebThreadImplForWorkerScheduler::Init() { |
33 base::WaitableEvent completion(false, false); | 35 base::WaitableEvent completion(false, false); |
34 thread_task_runner_->PostTask( | 36 thread_task_runner_->PostTask( |
35 FROM_HERE, base::Bind(&WebThreadImplForWorkerScheduler::InitOnThread, | 37 FROM_HERE, base::Bind(&WebThreadImplForWorkerScheduler::InitOnThread, |
36 base::Unretained(this), &completion)); | 38 base::Unretained(this), &completion)); |
37 completion.Wait(); | 39 completion.Wait(); |
38 } | 40 } |
39 | 41 |
40 WebThreadImplForWorkerScheduler::~WebThreadImplForWorkerScheduler() { | 42 WebThreadImplForWorkerScheduler::~WebThreadImplForWorkerScheduler() { |
41 base::WaitableEvent completion(false, false); | 43 if (task_runner_delegate_) { |
42 // Restore the original task runner so that the thread can tear itself down. | 44 base::WaitableEvent completion(false, false); |
43 thread_task_runner_->PostTask( | 45 // Restore the original task runner so that the thread can tear itself down. |
44 FROM_HERE, | 46 thread_task_runner_->PostTask( |
45 base::Bind(&WebThreadImplForWorkerScheduler::RestoreTaskRunnerOnThread, | 47 FROM_HERE, |
46 base::Unretained(this), &completion)); | 48 base::Bind(&WebThreadImplForWorkerScheduler::RestoreTaskRunnerOnThread, |
47 completion.Wait(); | 49 base::Unretained(this), &completion)); |
| 50 completion.Wait(); |
| 51 } |
48 thread_->Stop(); | 52 thread_->Stop(); |
49 } | 53 } |
50 | 54 |
51 void WebThreadImplForWorkerScheduler::InitOnThread( | 55 void WebThreadImplForWorkerScheduler::InitOnThread( |
52 base::WaitableEvent* completion) { | 56 base::WaitableEvent* completion) { |
53 // TODO(alexclarke): Do we need to unify virtual time for workers and the | 57 // TODO(alexclarke): Do we need to unify virtual time for workers and the |
54 // main thread? | 58 // main thread? |
55 task_runner_delegate_ = SchedulerTqmDelegateImpl::Create( | 59 worker_scheduler_ = CreateWorkerScheduler(); |
56 thread_->message_loop(), make_scoped_ptr(new base::DefaultTickClock())); | |
57 worker_scheduler_ = WorkerScheduler::Create(task_runner_delegate_); | |
58 worker_scheduler_->Init(); | 60 worker_scheduler_->Init(); |
59 task_runner_ = worker_scheduler_->DefaultTaskRunner(); | 61 task_runner_ = worker_scheduler_->DefaultTaskRunner(); |
60 idle_task_runner_ = worker_scheduler_->IdleTaskRunner(); | 62 idle_task_runner_ = worker_scheduler_->IdleTaskRunner(); |
61 web_scheduler_.reset(new WebSchedulerImpl( | 63 web_scheduler_.reset(new WebSchedulerImpl( |
62 worker_scheduler_.get(), worker_scheduler_->IdleTaskRunner(), | 64 worker_scheduler_.get(), worker_scheduler_->IdleTaskRunner(), |
63 worker_scheduler_->DefaultTaskRunner(), | 65 worker_scheduler_->DefaultTaskRunner(), |
64 worker_scheduler_->DefaultTaskRunner())); | 66 worker_scheduler_->DefaultTaskRunner())); |
65 base::MessageLoop::current()->AddDestructionObserver(this); | 67 base::MessageLoop::current()->AddDestructionObserver(this); |
66 web_task_runner_ = make_scoped_ptr(new WebTaskRunnerImpl(task_runner_)); | 68 web_task_runner_ = make_scoped_ptr(new WebTaskRunnerImpl(task_runner_)); |
67 completion->Signal(); | 69 completion->Signal(); |
68 } | 70 } |
69 | 71 |
70 void WebThreadImplForWorkerScheduler::RestoreTaskRunnerOnThread( | 72 void WebThreadImplForWorkerScheduler::RestoreTaskRunnerOnThread( |
71 base::WaitableEvent* completion) { | 73 base::WaitableEvent* completion) { |
72 task_runner_delegate_->RestoreDefaultTaskRunner(); | 74 task_runner_delegate_->RestoreDefaultTaskRunner(); |
73 completion->Signal(); | 75 completion->Signal(); |
74 } | 76 } |
75 | 77 |
76 void WebThreadImplForWorkerScheduler::WillDestroyCurrentMessageLoop() { | 78 void WebThreadImplForWorkerScheduler::WillDestroyCurrentMessageLoop() { |
77 task_runner_ = nullptr; | 79 task_runner_ = nullptr; |
78 idle_task_runner_ = nullptr; | 80 idle_task_runner_ = nullptr; |
79 web_scheduler_.reset(); | 81 web_scheduler_.reset(); |
80 worker_scheduler_.reset(); | 82 worker_scheduler_.reset(); |
81 } | 83 } |
82 | 84 |
| 85 scoped_ptr<scheduler::WorkerScheduler> |
| 86 WebThreadImplForWorkerScheduler::CreateWorkerScheduler() { |
| 87 task_runner_delegate_ = SchedulerTqmDelegateImpl::Create( |
| 88 thread_->message_loop(), make_scoped_ptr(new base::DefaultTickClock())); |
| 89 return WorkerScheduler::Create(task_runner_delegate_); |
| 90 } |
| 91 |
83 blink::PlatformThreadId WebThreadImplForWorkerScheduler::threadId() const { | 92 blink::PlatformThreadId WebThreadImplForWorkerScheduler::threadId() const { |
84 return thread_->GetThreadId(); | 93 return thread_->GetThreadId(); |
85 } | 94 } |
86 | 95 |
87 blink::WebScheduler* WebThreadImplForWorkerScheduler::scheduler() const { | 96 blink::WebScheduler* WebThreadImplForWorkerScheduler::scheduler() const { |
88 return web_scheduler_.get(); | 97 return web_scheduler_.get(); |
89 } | 98 } |
90 | 99 |
91 base::SingleThreadTaskRunner* WebThreadImplForWorkerScheduler::TaskRunner() | 100 base::SingleThreadTaskRunner* WebThreadImplForWorkerScheduler::TaskRunner() |
92 const { | 101 const { |
(...skipping 13 matching lines...) Expand all Loading... |
106 base::MessageLoop::TaskObserver* observer) { | 115 base::MessageLoop::TaskObserver* observer) { |
107 worker_scheduler_->AddTaskObserver(observer); | 116 worker_scheduler_->AddTaskObserver(observer); |
108 } | 117 } |
109 | 118 |
110 void WebThreadImplForWorkerScheduler::RemoveTaskObserverInternal( | 119 void WebThreadImplForWorkerScheduler::RemoveTaskObserverInternal( |
111 base::MessageLoop::TaskObserver* observer) { | 120 base::MessageLoop::TaskObserver* observer) { |
112 worker_scheduler_->RemoveTaskObserver(observer); | 121 worker_scheduler_->RemoveTaskObserver(observer); |
113 } | 122 } |
114 | 123 |
115 } // namespace scheduler | 124 } // namespace scheduler |
OLD | NEW |