OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "cc/raster/tile_task_worker_pool.h" | 5 #include "cc/raster/tile_task_worker_pool.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
45 const size_t kMaxBytesPerCopyOperation = 1000U; | 45 const size_t kMaxBytesPerCopyOperation = 1000U; |
46 const size_t kMaxStagingBuffers = 32U; | 46 const size_t kMaxStagingBuffers = 32U; |
47 | 47 |
48 enum TileTaskWorkerPoolType { | 48 enum TileTaskWorkerPoolType { |
49 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 49 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
50 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 50 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
51 TILE_TASK_WORKER_POOL_TYPE_GPU, | 51 TILE_TASK_WORKER_POOL_TYPE_GPU, |
52 TILE_TASK_WORKER_POOL_TYPE_BITMAP | 52 TILE_TASK_WORKER_POOL_TYPE_BITMAP |
53 }; | 53 }; |
54 | 54 |
55 class TileTaskWorkerPoolTest; | |
56 | |
55 class TestRasterTaskImpl : public RasterTask { | 57 class TestRasterTaskImpl : public RasterTask { |
56 public: | 58 public: |
57 typedef base::Callback<void(bool was_canceled)> Reply; | 59 TestRasterTaskImpl(std::unique_ptr<ScopedResource> resource, |
58 | 60 std::unique_ptr<RasterBuffer> raster_buffer, |
59 TestRasterTaskImpl(const Resource* resource, | |
60 const Reply& reply, | |
61 ImageDecodeTask::Vector* dependencies) | 61 ImageDecodeTask::Vector* dependencies) |
62 : RasterTask(dependencies), | 62 : RasterTask(dependencies), |
63 resource_(resource), | 63 resource_(std::move(resource)), |
64 reply_(reply), | 64 raster_buffer_(std::move(raster_buffer)), |
65 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} | 65 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) { |
66 SetTaskTypeId(kRasterTaskTypeId); | |
67 } | |
66 | 68 |
67 // Overridden from Task: | 69 // Overridden from Task: |
68 void RunOnWorkerThread() override { | 70 void RunOnWorkerThread() override { |
69 uint64_t new_content_id = 0; | 71 uint64_t new_content_id = 0; |
70 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), | 72 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), |
71 gfx::Rect(1, 1), new_content_id, 1.f, | 73 gfx::Rect(1, 1), new_content_id, 1.f, |
72 RasterSource::PlaybackSettings()); | 74 RasterSource::PlaybackSettings()); |
73 } | 75 } |
74 | 76 |
75 // Overridden from TileTask: | |
76 void ScheduleOnOriginThread(TileTaskClient* client) override { | |
77 // The raster buffer has no tile ids associated with it for partial update, | |
78 // so doesn't need to provide a valid dirty rect. | |
79 raster_buffer_ = client->AcquireBufferForRaster(resource_, 0, 0); | |
80 } | |
81 void CompleteOnOriginThread(TileTaskClient* client) override { | |
82 client->ReleaseBufferForRaster(std::move(raster_buffer_)); | |
83 reply_.Run(!HasFinishedRunning()); | |
84 } | |
85 | |
86 protected: | 77 protected: |
87 ~TestRasterTaskImpl() override {} | 78 ~TestRasterTaskImpl() override {} |
88 | 79 |
89 private: | 80 private: |
90 const Resource* resource_; | 81 friend class TileTaskWorkerPoolTest; |
91 const Reply reply_; | 82 std::unique_ptr<ScopedResource> resource_; |
92 std::unique_ptr<RasterBuffer> raster_buffer_; | 83 std::unique_ptr<RasterBuffer> raster_buffer_; |
93 scoped_refptr<RasterSource> raster_source_; | 84 scoped_refptr<RasterSource> raster_source_; |
94 | 85 |
95 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); | 86 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); |
96 }; | 87 }; |
97 | 88 |
98 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { | 89 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { |
99 public: | 90 public: |
100 BlockingTestRasterTaskImpl(const Resource* resource, | 91 BlockingTestRasterTaskImpl(std::unique_ptr<ScopedResource> resource, |
101 const Reply& reply, | 92 std::unique_ptr<RasterBuffer> raster_buffer, |
102 base::Lock* lock, | 93 base::Lock* lock, |
103 ImageDecodeTask::Vector* dependencies) | 94 ImageDecodeTask::Vector* dependencies) |
104 : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {} | 95 : TestRasterTaskImpl(std::move(resource), |
96 std::move(raster_buffer), | |
97 dependencies), | |
98 lock_(lock) {} | |
105 | 99 |
106 // Overridden from Task: | 100 // Overridden from Task: |
107 void RunOnWorkerThread() override { | 101 void RunOnWorkerThread() override { |
108 base::AutoLock lock(*lock_); | 102 base::AutoLock lock(*lock_); |
109 TestRasterTaskImpl::RunOnWorkerThread(); | 103 TestRasterTaskImpl::RunOnWorkerThread(); |
110 } | 104 } |
111 | 105 |
112 protected: | 106 protected: |
113 ~BlockingTestRasterTaskImpl() override {} | 107 ~BlockingTestRasterTaskImpl() override {} |
114 | 108 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
170 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | 164 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, |
171 resource_provider_.get()); | 165 resource_provider_.get()); |
172 break; | 166 break; |
173 } | 167 } |
174 | 168 |
175 DCHECK(tile_task_worker_pool_); | 169 DCHECK(tile_task_worker_pool_); |
176 } | 170 } |
177 | 171 |
178 void TearDown() override { | 172 void TearDown() override { |
179 tile_task_worker_pool_->AsTileTaskRunner()->Shutdown(); | 173 tile_task_worker_pool_->AsTileTaskRunner()->Shutdown(); |
180 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 174 CheckAndProcessCompletedTasks(); |
181 } | 175 } |
182 | 176 |
183 void AllTileTasksFinished() { | 177 void AllTileTasksFinished() { |
184 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 178 CheckAndProcessCompletedTasks(); |
185 base::MessageLoop::current()->QuitWhenIdle(); | 179 base::MessageLoop::current()->QuitWhenIdle(); |
186 } | 180 } |
187 | 181 |
182 void CheckAndProcessCompletedTasks() { | |
183 Task::Vector completed_tasks; | |
184 tile_task_worker_pool_->AsTileTaskRunner()->CollectCompletedTasks( | |
185 &completed_tasks); | |
186 | |
187 for (auto task : completed_tasks) { | |
prashant.n
2016/04/11 14:51:52
Add comment or processing completed imagedecodetas
| |
188 if (task->GetTaskTypeId() == kRasterTaskTypeId) { | |
189 TestRasterTaskImpl* raster_task = | |
190 static_cast<TestRasterTaskImpl*>(task.get()); | |
191 CompleteRasterTask(0, !raster_task->HasFinishedRunning()); | |
192 } | |
193 static_cast<TileTask*>(task.get())->DidComplete(); | |
194 } | |
195 } | |
196 | |
188 void RunMessageLoopUntilAllTasksHaveCompleted() { | 197 void RunMessageLoopUntilAllTasksHaveCompleted() { |
189 task_graph_runner_.RunUntilIdle(); | 198 task_graph_runner_.RunUntilIdle(); |
190 tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks(); | 199 CheckAndProcessCompletedTasks(); |
191 } | 200 } |
192 | 201 |
193 void ScheduleTasks() { | 202 void ScheduleTasks() { |
194 graph_.Reset(); | 203 graph_.Reset(); |
195 | 204 |
196 size_t priority = 0; | 205 size_t priority = 0; |
197 | 206 |
198 for (RasterTaskVector::const_iterator it = tasks_.begin(); | 207 for (RasterTaskVector::const_iterator it = tasks_.begin(); |
199 it != tasks_.end(); ++it) { | 208 it != tasks_.end(); ++it) { |
200 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, | 209 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, |
201 0 /* dependencies */); | 210 0 /* dependencies */); |
202 } | 211 } |
203 | 212 |
204 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph_); | 213 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph_); |
205 } | 214 } |
206 | 215 |
207 void AppendTask(unsigned id, const gfx::Size& size) { | 216 void AppendTask(unsigned id, const gfx::Size& size) { |
208 std::unique_ptr<ScopedResource> resource( | 217 std::unique_ptr<ScopedResource> resource( |
209 ScopedResource::Create(resource_provider_.get())); | 218 ScopedResource::Create(resource_provider_.get())); |
210 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 219 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
211 RGBA_8888); | 220 RGBA_8888); |
212 const Resource* const_resource = resource.get(); | 221 const Resource* const_resource = resource.get(); |
213 | 222 |
214 ImageDecodeTask::Vector empty; | 223 ImageDecodeTask::Vector empty; |
215 tasks_.push_back(new TestRasterTaskImpl( | 224 std::unique_ptr<RasterBuffer> raster_buffer = |
216 const_resource, | 225 tile_task_worker_pool_->AsTileTaskRunner() |
217 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | 226 ->AsTileTaskClient() |
218 base::Unretained(this), base::Passed(&resource), id), | 227 ->AcquireBufferForRaster(const_resource, 0, 0); |
219 &empty)); | 228 tasks_.push_back(new TestRasterTaskImpl(std::move(resource), |
229 std::move(raster_buffer), &empty)); | |
220 } | 230 } |
221 | 231 |
222 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | 232 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } |
223 | 233 |
224 void AppendBlockingTask(unsigned id, base::Lock* lock) { | 234 void AppendBlockingTask(unsigned id, base::Lock* lock) { |
225 const gfx::Size size(1, 1); | 235 const gfx::Size size(1, 1); |
226 | 236 |
227 std::unique_ptr<ScopedResource> resource( | 237 std::unique_ptr<ScopedResource> resource( |
228 ScopedResource::Create(resource_provider_.get())); | 238 ScopedResource::Create(resource_provider_.get())); |
229 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 239 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
230 RGBA_8888); | 240 RGBA_8888); |
231 const Resource* const_resource = resource.get(); | 241 const Resource* const_resource = resource.get(); |
232 | 242 |
233 ImageDecodeTask::Vector empty; | 243 ImageDecodeTask::Vector empty; |
244 std::unique_ptr<RasterBuffer> raster_buffer = | |
245 tile_task_worker_pool_->AsTileTaskRunner() | |
246 ->AsTileTaskClient() | |
247 ->AcquireBufferForRaster(const_resource, 0, 0); | |
248 | |
234 tasks_.push_back(new BlockingTestRasterTaskImpl( | 249 tasks_.push_back(new BlockingTestRasterTaskImpl( |
235 const_resource, | 250 std::move(resource), std::move(raster_buffer), lock, &empty)); |
236 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | |
237 base::Unretained(this), base::Passed(&resource), id), | |
238 lock, &empty)); | |
239 } | 251 } |
240 | 252 |
241 const std::vector<RasterTaskResult>& completed_tasks() const { | 253 const std::vector<RasterTaskResult>& completed_tasks() const { |
242 return completed_tasks_; | 254 return completed_tasks_; |
243 } | 255 } |
244 | 256 |
245 void LoseContext(ContextProvider* context_provider) { | 257 void LoseContext(ContextProvider* context_provider) { |
246 if (!context_provider) | 258 if (!context_provider) |
247 return; | 259 return; |
248 context_provider->ContextGL()->LoseContextCHROMIUM( | 260 context_provider->ContextGL()->LoseContextCHROMIUM( |
(...skipping 13 matching lines...) Expand all Loading... | |
262 } | 274 } |
263 | 275 |
264 void CreateSoftwareOutputSurfaceAndResourceProvider() { | 276 void CreateSoftwareOutputSurfaceAndResourceProvider() { |
265 output_surface_ = FakeOutputSurface::CreateSoftware( | 277 output_surface_ = FakeOutputSurface::CreateSoftware( |
266 base::WrapUnique(new SoftwareOutputDevice)); | 278 base::WrapUnique(new SoftwareOutputDevice)); |
267 CHECK(output_surface_->BindToClient(&output_surface_client_)); | 279 CHECK(output_surface_->BindToClient(&output_surface_client_)); |
268 resource_provider_ = FakeResourceProvider::Create( | 280 resource_provider_ = FakeResourceProvider::Create( |
269 output_surface_.get(), &shared_bitmap_manager_, nullptr); | 281 output_surface_.get(), &shared_bitmap_manager_, nullptr); |
270 } | 282 } |
271 | 283 |
272 void OnTaskCompleted(std::unique_ptr<ScopedResource> resource, | 284 void CompleteRasterTask(unsigned id, bool was_canceled) { |
273 unsigned id, | |
274 bool was_canceled) { | |
275 RasterTaskResult result; | 285 RasterTaskResult result; |
276 result.id = id; | 286 result.id = id; |
277 result.canceled = was_canceled; | 287 result.canceled = was_canceled; |
278 completed_tasks_.push_back(result); | 288 completed_tasks_.push_back(result); |
279 } | 289 } |
280 | 290 |
281 void OnTimeout() { | 291 void OnTimeout() { |
282 timed_out_ = true; | 292 timed_out_ = true; |
283 base::MessageLoop::current()->QuitWhenIdle(); | 293 base::MessageLoop::current()->QuitWhenIdle(); |
284 } | 294 } |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
370 | 380 |
371 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, | 381 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, |
372 TileTaskWorkerPoolTest, | 382 TileTaskWorkerPoolTest, |
373 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 383 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
374 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 384 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
375 TILE_TASK_WORKER_POOL_TYPE_GPU, | 385 TILE_TASK_WORKER_POOL_TYPE_GPU, |
376 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | 386 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); |
377 | 387 |
378 } // namespace | 388 } // namespace |
379 } // namespace cc | 389 } // namespace cc |
OLD | NEW |