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/raster_buffer_provider.h" | 5 #include "cc/raster/raster_buffer_provider.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 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, | 48 RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, |
49 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, | 49 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, |
50 RASTER_BUFFER_PROVIDER_TYPE_GPU, | 50 RASTER_BUFFER_PROVIDER_TYPE_GPU, |
51 RASTER_BUFFER_PROVIDER_TYPE_BITMAP | 51 RASTER_BUFFER_PROVIDER_TYPE_BITMAP |
52 }; | 52 }; |
53 | 53 |
54 class TestRasterTaskImpl : public TileTask { | 54 class TestRasterTaskImpl : public TileTask { |
55 public: | 55 public: |
56 typedef base::Callback<void(bool was_canceled)> Reply; | 56 typedef base::Callback<void(bool was_canceled)> Reply; |
57 | 57 |
58 TestRasterTaskImpl(const Resource* resource, | 58 TestRasterTaskImpl(std::unique_ptr<ScopedResource> resource, |
59 const Reply& reply, | 59 unsigned id, |
| 60 std::unique_ptr<RasterBuffer> raster_buffer, |
60 TileTask::Vector* dependencies) | 61 TileTask::Vector* dependencies) |
61 : TileTask(true, dependencies), | 62 : TileTask(TileTask::Type::RASTER, true, dependencies), |
62 resource_(resource), | 63 resource_(std::move(resource)), |
63 reply_(reply), | 64 id_(id), |
| 65 raster_buffer_(std::move(raster_buffer)), |
64 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} | 66 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} |
65 | 67 |
66 // Overridden from Task: | 68 // Overridden from Task: |
67 void RunOnWorkerThread() override { | 69 void RunOnWorkerThread() override { |
68 uint64_t new_content_id = 0; | 70 uint64_t new_content_id = 0; |
69 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), | 71 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), |
70 gfx::Rect(1, 1), new_content_id, 1.f, | 72 gfx::Rect(1, 1), new_content_id, 1.f, |
71 RasterSource::PlaybackSettings()); | 73 RasterSource::PlaybackSettings()); |
72 } | 74 } |
73 | 75 |
74 // Overridden from TileTask: | |
75 void ScheduleOnOriginThread(RasterBufferProvider* provider) override { | |
76 // The raster buffer has no tile ids associated with it for partial update, | |
77 // so doesn't need to provide a valid dirty rect. | |
78 raster_buffer_ = provider->AcquireBufferForRaster(resource_, 0, 0); | |
79 } | |
80 void CompleteOnOriginThread(RasterBufferProvider* provider) override { | |
81 provider->ReleaseBufferForRaster(std::move(raster_buffer_)); | |
82 reply_.Run(!state().IsFinished()); | |
83 } | |
84 | |
85 protected: | 76 protected: |
86 ~TestRasterTaskImpl() override {} | 77 ~TestRasterTaskImpl() override {} |
87 | 78 |
88 private: | 79 private: |
89 const Resource* resource_; | 80 friend class RasterBufferProviderTest; |
90 const Reply reply_; | 81 |
| 82 std::unique_ptr<ScopedResource> resource_; |
| 83 unsigned id_; |
91 std::unique_ptr<RasterBuffer> raster_buffer_; | 84 std::unique_ptr<RasterBuffer> raster_buffer_; |
92 scoped_refptr<RasterSource> raster_source_; | 85 scoped_refptr<RasterSource> raster_source_; |
93 | 86 |
94 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); | 87 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); |
95 }; | 88 }; |
96 | 89 |
97 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { | 90 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { |
98 public: | 91 public: |
99 BlockingTestRasterTaskImpl(const Resource* resource, | 92 BlockingTestRasterTaskImpl(std::unique_ptr<ScopedResource> resource, |
100 const Reply& reply, | 93 unsigned id, |
| 94 std::unique_ptr<RasterBuffer> raster_buffer, |
101 base::Lock* lock, | 95 base::Lock* lock, |
102 TileTask::Vector* dependencies) | 96 TileTask::Vector* dependencies) |
103 : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {} | 97 : TestRasterTaskImpl(std::move(resource), |
| 98 id, |
| 99 std::move(raster_buffer), |
| 100 dependencies), |
| 101 lock_(lock) {} |
104 | 102 |
105 // Overridden from Task: | 103 // Overridden from Task: |
106 void RunOnWorkerThread() override { | 104 void RunOnWorkerThread() override { |
107 base::AutoLock lock(*lock_); | 105 base::AutoLock lock(*lock_); |
108 TestRasterTaskImpl::RunOnWorkerThread(); | 106 TestRasterTaskImpl::RunOnWorkerThread(); |
109 } | 107 } |
110 | 108 |
111 protected: | 109 protected: |
112 ~BlockingTestRasterTaskImpl() override {} | 110 ~BlockingTestRasterTaskImpl() override {} |
113 | 111 |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
168 } | 166 } |
169 | 167 |
170 DCHECK(raster_buffer_provider); | 168 DCHECK(raster_buffer_provider); |
171 | 169 |
172 tile_task_manager_ = TileTaskManagerImpl::Create( | 170 tile_task_manager_ = TileTaskManagerImpl::Create( |
173 std::move(raster_buffer_provider), &task_graph_runner_); | 171 std::move(raster_buffer_provider), &task_graph_runner_); |
174 } | 172 } |
175 | 173 |
176 void TearDown() override { | 174 void TearDown() override { |
177 tile_task_manager_->Shutdown(); | 175 tile_task_manager_->Shutdown(); |
178 tile_task_manager_->CheckForCompletedTasks(); | 176 CheckForCompletedTasks(); |
179 } | 177 } |
180 | 178 |
181 void AllTileTasksFinished() { | 179 void AllTileTasksFinished() { |
182 tile_task_manager_->CheckForCompletedTasks(); | 180 CheckForCompletedTasks(); |
183 base::MessageLoop::current()->QuitWhenIdle(); | 181 base::MessageLoop::current()->QuitWhenIdle(); |
184 } | 182 } |
185 | 183 |
186 void RunMessageLoopUntilAllTasksHaveCompleted() { | 184 void RunMessageLoopUntilAllTasksHaveCompleted() { |
187 task_graph_runner_.RunUntilIdle(); | 185 task_graph_runner_.RunUntilIdle(); |
188 tile_task_manager_->CheckForCompletedTasks(); | 186 CheckForCompletedTasks(); |
189 } | 187 } |
190 | 188 |
191 void ScheduleTasks() { | 189 void ScheduleTasks() { |
192 graph_.Reset(); | 190 graph_.Reset(); |
193 | 191 |
194 size_t priority = 0; | 192 size_t priority = 0; |
195 | 193 |
196 for (RasterTaskVector::const_iterator it = tasks_.begin(); | 194 for (RasterTaskVector::const_iterator it = tasks_.begin(); |
197 it != tasks_.end(); ++it) { | 195 it != tasks_.end(); ++it) { |
198 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, | 196 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, |
199 0 /* dependencies */); | 197 0 /* dependencies */); |
200 } | 198 } |
201 | 199 |
202 tile_task_manager_->ScheduleTasks(&graph_); | 200 tile_task_manager_->ScheduleTasks(&graph_); |
203 } | 201 } |
204 | 202 |
205 void AppendTask(unsigned id, const gfx::Size& size) { | 203 void AppendTask(unsigned id, const gfx::Size& size) { |
206 std::unique_ptr<ScopedResource> resource( | 204 std::unique_ptr<ScopedResource> resource( |
207 ScopedResource::Create(resource_provider_.get())); | 205 ScopedResource::Create(resource_provider_.get())); |
208 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 206 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
209 RGBA_8888); | 207 RGBA_8888); |
210 const Resource* const_resource = resource.get(); | |
211 | 208 |
| 209 // The raster buffer has no tile ids associated with it for partial update, |
| 210 // so doesn't need to provide a valid dirty rect. |
| 211 std::unique_ptr<RasterBuffer> raster_buffer = |
| 212 tile_task_manager_->GetRasterBufferProvider()->AcquireBufferForRaster( |
| 213 resource.get(), 0, 0); |
212 TileTask::Vector empty; | 214 TileTask::Vector empty; |
213 tasks_.push_back(new TestRasterTaskImpl( | 215 tasks_.push_back(new TestRasterTaskImpl(std::move(resource), id, |
214 const_resource, | 216 std::move(raster_buffer), &empty)); |
215 base::Bind(&RasterBufferProviderTest::OnTaskCompleted, | |
216 base::Unretained(this), base::Passed(&resource), id), | |
217 &empty)); | |
218 } | 217 } |
219 | 218 |
220 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | 219 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } |
221 | 220 |
222 void AppendBlockingTask(unsigned id, base::Lock* lock) { | 221 void AppendBlockingTask(unsigned id, base::Lock* lock) { |
223 const gfx::Size size(1, 1); | 222 const gfx::Size size(1, 1); |
224 | 223 |
225 std::unique_ptr<ScopedResource> resource( | 224 std::unique_ptr<ScopedResource> resource( |
226 ScopedResource::Create(resource_provider_.get())); | 225 ScopedResource::Create(resource_provider_.get())); |
227 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 226 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
228 RGBA_8888); | 227 RGBA_8888); |
229 const Resource* const_resource = resource.get(); | |
230 | 228 |
| 229 std::unique_ptr<RasterBuffer> raster_buffer = |
| 230 tile_task_manager_->GetRasterBufferProvider()->AcquireBufferForRaster( |
| 231 resource.get(), 0, 0); |
231 TileTask::Vector empty; | 232 TileTask::Vector empty; |
232 tasks_.push_back(new BlockingTestRasterTaskImpl( | 233 tasks_.push_back(new BlockingTestRasterTaskImpl( |
233 const_resource, | 234 std::move(resource), id, std::move(raster_buffer), lock, &empty)); |
234 base::Bind(&RasterBufferProviderTest::OnTaskCompleted, | |
235 base::Unretained(this), base::Passed(&resource), id), | |
236 lock, &empty)); | |
237 } | 235 } |
238 | 236 |
239 const std::vector<RasterTaskResult>& completed_tasks() const { | 237 const std::vector<RasterTaskResult>& completed_tasks() const { |
240 return completed_tasks_; | 238 return completed_tasks_; |
241 } | 239 } |
242 | 240 |
243 void LoseContext(ContextProvider* context_provider) { | 241 void LoseContext(ContextProvider* context_provider) { |
244 if (!context_provider) | 242 if (!context_provider) |
245 return; | 243 return; |
246 context_provider->ContextGL()->LoseContextCHROMIUM( | 244 context_provider->ContextGL()->LoseContextCHROMIUM( |
(...skipping 13 matching lines...) Expand all Loading... |
260 } | 258 } |
261 | 259 |
262 void CreateSoftwareOutputSurfaceAndResourceProvider() { | 260 void CreateSoftwareOutputSurfaceAndResourceProvider() { |
263 output_surface_ = FakeOutputSurface::CreateSoftware( | 261 output_surface_ = FakeOutputSurface::CreateSoftware( |
264 base::WrapUnique(new SoftwareOutputDevice)); | 262 base::WrapUnique(new SoftwareOutputDevice)); |
265 CHECK(output_surface_->BindToClient(&output_surface_client_)); | 263 CHECK(output_surface_->BindToClient(&output_surface_client_)); |
266 resource_provider_ = FakeResourceProvider::Create( | 264 resource_provider_ = FakeResourceProvider::Create( |
267 output_surface_.get(), &shared_bitmap_manager_, nullptr); | 265 output_surface_.get(), &shared_bitmap_manager_, nullptr); |
268 } | 266 } |
269 | 267 |
270 void OnTaskCompleted(std::unique_ptr<ScopedResource> resource, | 268 void CheckForCompletedTasks() { |
271 unsigned id, | 269 Task::Vector completed_tasks; |
272 bool was_canceled) { | 270 tile_task_manager_->CollectCompletedTasks(&completed_tasks); |
| 271 |
| 272 for (auto task : completed_tasks) { |
| 273 TileTask* tile_task = static_cast<TileTask*>(task.get()); |
| 274 switch (tile_task->type()) { |
| 275 case TileTask::Type::RASTER: |
| 276 OnRasterTaskCompleted(tile_task); |
| 277 break; |
| 278 default: |
| 279 NOTREACHED(); |
| 280 } |
| 281 |
| 282 task->state().DidComplete(); |
| 283 } |
| 284 |
| 285 completed_tasks.clear(); |
| 286 } |
| 287 |
| 288 void OnRasterTaskCompleted(TileTask* task) { |
| 289 TestRasterTaskImpl* raster_task = static_cast<TestRasterTaskImpl*>(task); |
| 290 tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster( |
| 291 std::move(raster_task->raster_buffer_)); |
273 RasterTaskResult result; | 292 RasterTaskResult result; |
274 result.id = id; | 293 result.id = raster_task->id_; |
275 result.canceled = was_canceled; | 294 result.canceled = raster_task->state().IsCanceled(); |
276 completed_tasks_.push_back(result); | 295 completed_tasks_.push_back(result); |
277 } | 296 } |
278 | 297 |
279 void OnTimeout() { | 298 void OnTimeout() { |
280 timed_out_ = true; | 299 timed_out_ = true; |
281 base::MessageLoop::current()->QuitWhenIdle(); | 300 base::MessageLoop::current()->QuitWhenIdle(); |
282 } | 301 } |
283 | 302 |
284 protected: | 303 protected: |
285 scoped_refptr<TestContextProvider> context_provider_; | 304 scoped_refptr<TestContextProvider> context_provider_; |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
368 | 387 |
369 INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests, | 388 INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests, |
370 RasterBufferProviderTest, | 389 RasterBufferProviderTest, |
371 ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, | 390 ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, |
372 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, | 391 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, |
373 RASTER_BUFFER_PROVIDER_TYPE_GPU, | 392 RASTER_BUFFER_PROVIDER_TYPE_GPU, |
374 RASTER_BUFFER_PROVIDER_TYPE_BITMAP)); | 393 RASTER_BUFFER_PROVIDER_TYPE_BITMAP)); |
375 | 394 |
376 } // namespace | 395 } // namespace |
377 } // namespace cc | 396 } // namespace cc |
OLD | NEW |