OLD | NEW |
| (Empty) |
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 #include "cc/resources/direct_raster_worker_pool.h" | |
6 | |
7 #include "base/debug/trace_event.h" | |
8 #include "cc/output/context_provider.h" | |
9 #include "cc/resources/resource.h" | |
10 #include "cc/resources/resource_provider.h" | |
11 #include "gpu/command_buffer/client/gles2_interface.h" | |
12 #include "third_party/skia/include/gpu/GrContext.h" | |
13 | |
14 namespace cc { | |
15 | |
16 // static | |
17 scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create( | |
18 base::SequencedTaskRunner* task_runner, | |
19 ResourceProvider* resource_provider, | |
20 ContextProvider* context_provider) { | |
21 return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool( | |
22 task_runner, resource_provider, context_provider)); | |
23 } | |
24 | |
25 DirectRasterWorkerPool::DirectRasterWorkerPool( | |
26 base::SequencedTaskRunner* task_runner, | |
27 ResourceProvider* resource_provider, | |
28 ContextProvider* context_provider) | |
29 : task_runner_(task_runner), | |
30 task_graph_runner_(new TaskGraphRunner), | |
31 namespace_token_(task_graph_runner_->GetNamespaceToken()), | |
32 resource_provider_(resource_provider), | |
33 context_provider_(context_provider), | |
34 run_tasks_on_origin_thread_pending_(false), | |
35 raster_tasks_pending_(false), | |
36 raster_tasks_required_for_activation_pending_(false), | |
37 raster_finished_weak_ptr_factory_(this), | |
38 weak_ptr_factory_(this) {} | |
39 | |
40 DirectRasterWorkerPool::~DirectRasterWorkerPool() { | |
41 DCHECK_EQ(0u, completed_tasks_.size()); | |
42 } | |
43 | |
44 Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; } | |
45 | |
46 void DirectRasterWorkerPool::SetClient(RasterizerClient* client) { | |
47 client_ = client; | |
48 } | |
49 | |
50 void DirectRasterWorkerPool::Shutdown() { | |
51 TRACE_EVENT0("cc", "DirectRasterWorkerPool::Shutdown"); | |
52 | |
53 TaskGraph empty; | |
54 task_graph_runner_->ScheduleTasks(namespace_token_, &empty); | |
55 task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_); | |
56 } | |
57 | |
58 void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) { | |
59 TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks"); | |
60 | |
61 DCHECK_EQ(queue->required_for_activation_count, | |
62 static_cast<size_t>( | |
63 std::count_if(queue->items.begin(), | |
64 queue->items.end(), | |
65 RasterTaskQueue::Item::IsRequiredForActivation))); | |
66 | |
67 raster_tasks_pending_ = true; | |
68 raster_tasks_required_for_activation_pending_ = true; | |
69 | |
70 unsigned priority = kRasterTaskPriorityBase; | |
71 | |
72 graph_.Reset(); | |
73 | |
74 // Cancel existing OnRasterFinished callbacks. | |
75 raster_finished_weak_ptr_factory_.InvalidateWeakPtrs(); | |
76 | |
77 scoped_refptr<RasterizerTask> | |
78 new_raster_required_for_activation_finished_task( | |
79 CreateRasterRequiredForActivationFinishedTask( | |
80 queue->required_for_activation_count, | |
81 task_runner_.get(), | |
82 base::Bind(&DirectRasterWorkerPool:: | |
83 OnRasterRequiredForActivationFinished, | |
84 raster_finished_weak_ptr_factory_.GetWeakPtr()))); | |
85 scoped_refptr<RasterizerTask> new_raster_finished_task( | |
86 CreateRasterFinishedTask( | |
87 task_runner_.get(), | |
88 base::Bind(&DirectRasterWorkerPool::OnRasterFinished, | |
89 raster_finished_weak_ptr_factory_.GetWeakPtr()))); | |
90 | |
91 for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin(); | |
92 it != queue->items.end(); | |
93 ++it) { | |
94 const RasterTaskQueue::Item& item = *it; | |
95 RasterTask* task = item.task; | |
96 DCHECK(!task->HasCompleted()); | |
97 | |
98 if (item.required_for_activation) { | |
99 graph_.edges.push_back(TaskGraph::Edge( | |
100 task, new_raster_required_for_activation_finished_task.get())); | |
101 } | |
102 | |
103 InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++); | |
104 | |
105 graph_.edges.push_back( | |
106 TaskGraph::Edge(task, new_raster_finished_task.get())); | |
107 } | |
108 | |
109 InsertNodeForTask(&graph_, | |
110 new_raster_required_for_activation_finished_task.get(), | |
111 kRasterRequiredForActivationFinishedTaskPriority, | |
112 queue->required_for_activation_count); | |
113 InsertNodeForTask(&graph_, | |
114 new_raster_finished_task.get(), | |
115 kRasterFinishedTaskPriority, | |
116 queue->items.size()); | |
117 | |
118 ScheduleTasksOnOriginThread(this, &graph_); | |
119 task_graph_runner_->ScheduleTasks(namespace_token_, &graph_); | |
120 | |
121 ScheduleRunTasksOnOriginThread(); | |
122 | |
123 raster_finished_task_ = new_raster_finished_task; | |
124 raster_required_for_activation_finished_task_ = | |
125 new_raster_required_for_activation_finished_task; | |
126 } | |
127 | |
128 void DirectRasterWorkerPool::CheckForCompletedTasks() { | |
129 TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks"); | |
130 | |
131 task_graph_runner_->CollectCompletedTasks(namespace_token_, | |
132 &completed_tasks_); | |
133 for (Task::Vector::const_iterator it = completed_tasks_.begin(); | |
134 it != completed_tasks_.end(); | |
135 ++it) { | |
136 RasterizerTask* task = static_cast<RasterizerTask*>(it->get()); | |
137 | |
138 task->WillComplete(); | |
139 task->CompleteOnOriginThread(this); | |
140 task->DidComplete(); | |
141 | |
142 task->RunReplyOnOriginThread(); | |
143 } | |
144 completed_tasks_.clear(); | |
145 } | |
146 | |
147 SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) { | |
148 return resource_provider_->MapDirectRasterBuffer(task->resource()->id()); | |
149 } | |
150 | |
151 void DirectRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) { | |
152 resource_provider_->UnmapDirectRasterBuffer(task->resource()->id()); | |
153 } | |
154 | |
155 void DirectRasterWorkerPool::OnRasterFinished() { | |
156 TRACE_EVENT0("cc", "DirectRasterWorkerPool::OnRasterFinished"); | |
157 | |
158 DCHECK(raster_tasks_pending_); | |
159 raster_tasks_pending_ = false; | |
160 client_->DidFinishRunningTasks(); | |
161 } | |
162 | |
163 void DirectRasterWorkerPool::OnRasterRequiredForActivationFinished() { | |
164 TRACE_EVENT0("cc", | |
165 "DirectRasterWorkerPool::OnRasterRequiredForActivationFinished"); | |
166 | |
167 DCHECK(raster_tasks_required_for_activation_pending_); | |
168 raster_tasks_required_for_activation_pending_ = false; | |
169 client_->DidFinishRunningTasksRequiredForActivation(); | |
170 } | |
171 | |
172 void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() { | |
173 if (run_tasks_on_origin_thread_pending_) | |
174 return; | |
175 | |
176 task_runner_->PostTask( | |
177 FROM_HERE, | |
178 base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread, | |
179 weak_ptr_factory_.GetWeakPtr())); | |
180 run_tasks_on_origin_thread_pending_ = true; | |
181 } | |
182 | |
183 void DirectRasterWorkerPool::RunTasksOnOriginThread() { | |
184 TRACE_EVENT0("cc", "DirectRasterWorkerPool::RunTasksOnOriginThread"); | |
185 | |
186 DCHECK(run_tasks_on_origin_thread_pending_); | |
187 run_tasks_on_origin_thread_pending_ = false; | |
188 | |
189 if (context_provider_) { | |
190 DCHECK(context_provider_->ContextGL()); | |
191 // TODO(alokp): Use a trace macro to push/pop markers. | |
192 // Using push/pop functions directly incurs cost to evaluate function | |
193 // arguments even when tracing is disabled. | |
194 context_provider_->ContextGL()->PushGroupMarkerEXT( | |
195 0, "DirectRasterWorkerPool::RunTasksOnOriginThread"); | |
196 | |
197 GrContext* gr_context = context_provider_->GrContext(); | |
198 // TODO(alokp): Implement TestContextProvider::GrContext(). | |
199 if (gr_context) | |
200 gr_context->resetContext(); | |
201 } | |
202 | |
203 task_graph_runner_->RunUntilIdle(); | |
204 | |
205 if (context_provider_) { | |
206 GrContext* gr_context = context_provider_->GrContext(); | |
207 // TODO(alokp): Implement TestContextProvider::GrContext(). | |
208 if (gr_context) | |
209 gr_context->flush(); | |
210 | |
211 context_provider_->ContextGL()->PopGroupMarkerEXT(); | |
212 } | |
213 } | |
214 | |
215 } // namespace cc | |
OLD | NEW |