| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/resources/raster_worker_pool.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/cancelable_callback.h" | |
| 11 #include "cc/resources/bitmap_raster_worker_pool.h" | |
| 12 #include "cc/resources/gpu_raster_worker_pool.h" | |
| 13 #include "cc/resources/one_copy_raster_worker_pool.h" | |
| 14 #include "cc/resources/picture_pile.h" | |
| 15 #include "cc/resources/picture_pile_impl.h" | |
| 16 #include "cc/resources/pixel_buffer_raster_worker_pool.h" | |
| 17 #include "cc/resources/raster_buffer.h" | |
| 18 #include "cc/resources/rasterizer.h" | |
| 19 #include "cc/resources/resource_pool.h" | |
| 20 #include "cc/resources/resource_provider.h" | |
| 21 #include "cc/resources/scoped_resource.h" | |
| 22 #include "cc/resources/zero_copy_raster_worker_pool.h" | |
| 23 #include "cc/test/fake_output_surface.h" | |
| 24 #include "cc/test/fake_output_surface_client.h" | |
| 25 #include "cc/test/fake_picture_pile_impl.h" | |
| 26 #include "cc/test/test_gpu_memory_buffer_manager.h" | |
| 27 #include "cc/test/test_shared_bitmap_manager.h" | |
| 28 #include "cc/test/test_web_graphics_context_3d.h" | |
| 29 #include "testing/gtest/include/gtest/gtest.h" | |
| 30 | |
| 31 namespace cc { | |
| 32 namespace { | |
| 33 | |
| 34 const size_t kMaxTransferBufferUsageBytes = 10000U; | |
| 35 // A resource of this dimension^2 * 4 must be greater than the above transfer | |
| 36 // buffer constant. | |
| 37 const size_t kLargeResourceDimension = 1000U; | |
| 38 | |
| 39 enum RasterWorkerPoolType { | |
| 40 RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER, | |
| 41 RASTER_WORKER_POOL_TYPE_ZERO_COPY, | |
| 42 RASTER_WORKER_POOL_TYPE_ONE_COPY, | |
| 43 RASTER_WORKER_POOL_TYPE_GPU, | |
| 44 RASTER_WORKER_POOL_TYPE_BITMAP | |
| 45 }; | |
| 46 | |
| 47 class TestRasterTaskImpl : public RasterTask { | |
| 48 public: | |
| 49 typedef base::Callback<void(const RasterSource::SolidColorAnalysis& analysis, | |
| 50 bool was_canceled)> Reply; | |
| 51 | |
| 52 TestRasterTaskImpl(const Resource* resource, | |
| 53 const Reply& reply, | |
| 54 ImageDecodeTask::Vector* dependencies) | |
| 55 : RasterTask(resource, dependencies), | |
| 56 reply_(reply), | |
| 57 picture_pile_(FakePicturePileImpl::CreateEmptyPile(gfx::Size(1, 1), | |
| 58 gfx::Size(1, 1))) {} | |
| 59 | |
| 60 // Overridden from Task: | |
| 61 void RunOnWorkerThread() override { | |
| 62 raster_buffer_->Playback(picture_pile_.get(), gfx::Rect(0, 0, 1, 1), 1.0); | |
| 63 } | |
| 64 | |
| 65 // Overridden from RasterizerTask: | |
| 66 void ScheduleOnOriginThread(RasterizerTaskClient* client) override { | |
| 67 raster_buffer_ = client->AcquireBufferForRaster(resource()); | |
| 68 } | |
| 69 void CompleteOnOriginThread(RasterizerTaskClient* client) override { | |
| 70 client->ReleaseBufferForRaster(raster_buffer_.Pass()); | |
| 71 } | |
| 72 void RunReplyOnOriginThread() override { | |
| 73 reply_.Run(RasterSource::SolidColorAnalysis(), !HasFinishedRunning()); | |
| 74 } | |
| 75 | |
| 76 protected: | |
| 77 ~TestRasterTaskImpl() override {} | |
| 78 | |
| 79 private: | |
| 80 const Reply reply_; | |
| 81 scoped_ptr<RasterBuffer> raster_buffer_; | |
| 82 scoped_refptr<PicturePileImpl> picture_pile_; | |
| 83 | |
| 84 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); | |
| 85 }; | |
| 86 | |
| 87 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { | |
| 88 public: | |
| 89 BlockingTestRasterTaskImpl(const Resource* resource, | |
| 90 const Reply& reply, | |
| 91 base::Lock* lock, | |
| 92 ImageDecodeTask::Vector* dependencies) | |
| 93 : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {} | |
| 94 | |
| 95 // Overridden from Task: | |
| 96 void RunOnWorkerThread() override { | |
| 97 base::AutoLock lock(*lock_); | |
| 98 TestRasterTaskImpl::RunOnWorkerThread(); | |
| 99 } | |
| 100 | |
| 101 // Overridden from RasterizerTask: | |
| 102 void RunReplyOnOriginThread() override {} | |
| 103 | |
| 104 protected: | |
| 105 ~BlockingTestRasterTaskImpl() override {} | |
| 106 | |
| 107 private: | |
| 108 base::Lock* lock_; | |
| 109 | |
| 110 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); | |
| 111 }; | |
| 112 | |
| 113 class RasterWorkerPoolTest | |
| 114 : public testing::TestWithParam<RasterWorkerPoolType>, | |
| 115 public RasterizerClient { | |
| 116 public: | |
| 117 struct RasterTaskResult { | |
| 118 unsigned id; | |
| 119 bool canceled; | |
| 120 }; | |
| 121 | |
| 122 typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector; | |
| 123 | |
| 124 enum NamedTaskSet { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW }; | |
| 125 | |
| 126 RasterWorkerPoolTest() | |
| 127 : context_provider_(TestContextProvider::Create()), | |
| 128 timeout_seconds_(5), | |
| 129 timed_out_(false) {} | |
| 130 | |
| 131 // Overridden from testing::Test: | |
| 132 void SetUp() override { | |
| 133 switch (GetParam()) { | |
| 134 case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER: | |
| 135 Create3dOutputSurfaceAndResourceProvider(); | |
| 136 raster_worker_pool_ = PixelBufferRasterWorkerPool::Create( | |
| 137 base::MessageLoopProxy::current().get(), | |
| 138 RasterWorkerPool::GetTaskGraphRunner(), | |
| 139 context_provider_.get(), | |
| 140 resource_provider_.get(), | |
| 141 kMaxTransferBufferUsageBytes); | |
| 142 break; | |
| 143 case RASTER_WORKER_POOL_TYPE_ZERO_COPY: | |
| 144 Create3dOutputSurfaceAndResourceProvider(); | |
| 145 raster_worker_pool_ = ZeroCopyRasterWorkerPool::Create( | |
| 146 base::MessageLoopProxy::current().get(), | |
| 147 RasterWorkerPool::GetTaskGraphRunner(), | |
| 148 resource_provider_.get()); | |
| 149 break; | |
| 150 case RASTER_WORKER_POOL_TYPE_ONE_COPY: | |
| 151 Create3dOutputSurfaceAndResourceProvider(); | |
| 152 staging_resource_pool_ = ResourcePool::Create( | |
| 153 resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888); | |
| 154 raster_worker_pool_ = OneCopyRasterWorkerPool::Create( | |
| 155 base::MessageLoopProxy::current().get(), | |
| 156 RasterWorkerPool::GetTaskGraphRunner(), | |
| 157 context_provider_.get(), | |
| 158 resource_provider_.get(), | |
| 159 staging_resource_pool_.get()); | |
| 160 break; | |
| 161 case RASTER_WORKER_POOL_TYPE_GPU: | |
| 162 Create3dOutputSurfaceAndResourceProvider(); | |
| 163 raster_worker_pool_ = | |
| 164 GpuRasterWorkerPool::Create(base::MessageLoopProxy::current().get(), | |
| 165 context_provider_.get(), | |
| 166 resource_provider_.get(), | |
| 167 false); | |
| 168 break; | |
| 169 case RASTER_WORKER_POOL_TYPE_BITMAP: | |
| 170 CreateSoftwareOutputSurfaceAndResourceProvider(); | |
| 171 raster_worker_pool_ = BitmapRasterWorkerPool::Create( | |
| 172 base::MessageLoopProxy::current().get(), | |
| 173 RasterWorkerPool::GetTaskGraphRunner(), | |
| 174 resource_provider_.get()); | |
| 175 break; | |
| 176 } | |
| 177 | |
| 178 DCHECK(raster_worker_pool_); | |
| 179 raster_worker_pool_->AsRasterizer()->SetClient(this); | |
| 180 } | |
| 181 | |
| 182 void TearDown() override { | |
| 183 raster_worker_pool_->AsRasterizer()->Shutdown(); | |
| 184 raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks(); | |
| 185 } | |
| 186 | |
| 187 // Overriden from RasterWorkerPoolClient: | |
| 188 void DidFinishRunningTasks(TaskSet task_set) override { | |
| 189 if (task_set == ALL) { | |
| 190 raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks(); | |
| 191 base::MessageLoop::current()->Quit(); | |
| 192 } | |
| 193 } | |
| 194 TaskSetCollection TasksThatShouldBeForcedToComplete() const override { | |
| 195 return TaskSetCollection(); | |
| 196 } | |
| 197 | |
| 198 void RunMessageLoopUntilAllTasksHaveCompleted() { | |
| 199 if (timeout_seconds_) { | |
| 200 timeout_.Reset( | |
| 201 base::Bind(&RasterWorkerPoolTest::OnTimeout, base::Unretained(this))); | |
| 202 base::MessageLoopProxy::current()->PostDelayedTask( | |
| 203 FROM_HERE, | |
| 204 timeout_.callback(), | |
| 205 base::TimeDelta::FromSeconds(timeout_seconds_)); | |
| 206 } | |
| 207 | |
| 208 base::MessageLoop::current()->Run(); | |
| 209 | |
| 210 timeout_.Cancel(); | |
| 211 | |
| 212 ASSERT_FALSE(timed_out_) << "Test timed out"; | |
| 213 } | |
| 214 | |
| 215 void ScheduleTasks() { | |
| 216 RasterTaskQueue queue; | |
| 217 | |
| 218 for (RasterTaskVector::const_iterator it = tasks_.begin(); | |
| 219 it != tasks_.end(); | |
| 220 ++it) { | |
| 221 TaskSetCollection task_sets; | |
| 222 task_sets[ALL] = true; | |
| 223 queue.items.push_back(RasterTaskQueue::Item(it->get(), task_sets)); | |
| 224 } | |
| 225 | |
| 226 raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue); | |
| 227 } | |
| 228 | |
| 229 void AppendTask(unsigned id, const gfx::Size& size) { | |
| 230 scoped_ptr<ScopedResource> resource( | |
| 231 ScopedResource::Create(resource_provider_.get())); | |
| 232 resource->Allocate(size, ResourceProvider::TextureHintImmutable, RGBA_8888); | |
| 233 const Resource* const_resource = resource.get(); | |
| 234 | |
| 235 ImageDecodeTask::Vector empty; | |
| 236 tasks_.push_back(new TestRasterTaskImpl( | |
| 237 const_resource, | |
| 238 base::Bind(&RasterWorkerPoolTest::OnTaskCompleted, | |
| 239 base::Unretained(this), | |
| 240 base::Passed(&resource), | |
| 241 id), | |
| 242 &empty)); | |
| 243 } | |
| 244 | |
| 245 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | |
| 246 | |
| 247 void AppendBlockingTask(unsigned id, base::Lock* lock) { | |
| 248 const gfx::Size size(1, 1); | |
| 249 | |
| 250 scoped_ptr<ScopedResource> resource( | |
| 251 ScopedResource::Create(resource_provider_.get())); | |
| 252 resource->Allocate(size, ResourceProvider::TextureHintImmutable, RGBA_8888); | |
| 253 const Resource* const_resource = resource.get(); | |
| 254 | |
| 255 ImageDecodeTask::Vector empty; | |
| 256 tasks_.push_back(new BlockingTestRasterTaskImpl( | |
| 257 const_resource, | |
| 258 base::Bind(&RasterWorkerPoolTest::OnTaskCompleted, | |
| 259 base::Unretained(this), | |
| 260 base::Passed(&resource), | |
| 261 id), | |
| 262 lock, | |
| 263 &empty)); | |
| 264 } | |
| 265 | |
| 266 const std::vector<RasterTaskResult>& completed_tasks() const { | |
| 267 return completed_tasks_; | |
| 268 } | |
| 269 | |
| 270 private: | |
| 271 void Create3dOutputSurfaceAndResourceProvider() { | |
| 272 output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass(); | |
| 273 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 274 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); | |
| 275 context3d->set_support_sync_query(true); | |
| 276 resource_provider_ = ResourceProvider::Create(output_surface_.get(), | |
| 277 NULL, | |
| 278 &gpu_memory_buffer_manager_, | |
| 279 NULL, | |
| 280 0, | |
| 281 false, | |
| 282 1).Pass(); | |
| 283 } | |
| 284 | |
| 285 void CreateSoftwareOutputSurfaceAndResourceProvider() { | |
| 286 output_surface_ = FakeOutputSurface::CreateSoftware( | |
| 287 make_scoped_ptr(new SoftwareOutputDevice)); | |
| 288 CHECK(output_surface_->BindToClient(&output_surface_client_)); | |
| 289 resource_provider_ = ResourceProvider::Create(output_surface_.get(), | |
| 290 &shared_bitmap_manager_, | |
| 291 NULL, | |
| 292 NULL, | |
| 293 0, | |
| 294 false, | |
| 295 1).Pass(); | |
| 296 } | |
| 297 | |
| 298 void OnTaskCompleted(scoped_ptr<ScopedResource> resource, | |
| 299 unsigned id, | |
| 300 const RasterSource::SolidColorAnalysis& analysis, | |
| 301 bool was_canceled) { | |
| 302 RasterTaskResult result; | |
| 303 result.id = id; | |
| 304 result.canceled = was_canceled; | |
| 305 completed_tasks_.push_back(result); | |
| 306 } | |
| 307 | |
| 308 void OnTimeout() { | |
| 309 timed_out_ = true; | |
| 310 base::MessageLoop::current()->Quit(); | |
| 311 } | |
| 312 | |
| 313 protected: | |
| 314 scoped_refptr<TestContextProvider> context_provider_; | |
| 315 FakeOutputSurfaceClient output_surface_client_; | |
| 316 scoped_ptr<FakeOutputSurface> output_surface_; | |
| 317 scoped_ptr<ResourceProvider> resource_provider_; | |
| 318 scoped_ptr<ResourcePool> staging_resource_pool_; | |
| 319 scoped_ptr<RasterWorkerPool> raster_worker_pool_; | |
| 320 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; | |
| 321 TestSharedBitmapManager shared_bitmap_manager_; | |
| 322 base::CancelableClosure timeout_; | |
| 323 int timeout_seconds_; | |
| 324 bool timed_out_; | |
| 325 RasterTaskVector tasks_; | |
| 326 std::vector<RasterTaskResult> completed_tasks_; | |
| 327 }; | |
| 328 | |
| 329 TEST_P(RasterWorkerPoolTest, Basic) { | |
| 330 AppendTask(0u); | |
| 331 AppendTask(1u); | |
| 332 ScheduleTasks(); | |
| 333 | |
| 334 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 335 | |
| 336 ASSERT_EQ(2u, completed_tasks().size()); | |
| 337 EXPECT_FALSE(completed_tasks()[0].canceled); | |
| 338 EXPECT_FALSE(completed_tasks()[1].canceled); | |
| 339 } | |
| 340 | |
| 341 TEST_P(RasterWorkerPoolTest, FailedMapResource) { | |
| 342 if (GetParam() == RASTER_WORKER_POOL_TYPE_BITMAP) | |
| 343 return; | |
| 344 | |
| 345 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); | |
| 346 context3d->set_times_map_buffer_chromium_succeeds(0); | |
| 347 AppendTask(0u); | |
| 348 ScheduleTasks(); | |
| 349 | |
| 350 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 351 | |
| 352 ASSERT_EQ(1u, completed_tasks().size()); | |
| 353 EXPECT_FALSE(completed_tasks()[0].canceled); | |
| 354 } | |
| 355 | |
| 356 // This test checks that replacing a pending raster task with another does | |
| 357 // not prevent the DidFinishRunningTasks notification from being sent. | |
| 358 TEST_P(RasterWorkerPoolTest, FalseThrottling) { | |
| 359 base::Lock lock; | |
| 360 | |
| 361 // Schedule a task that is prevented from completing with a lock. | |
| 362 lock.Acquire(); | |
| 363 AppendBlockingTask(0u, &lock); | |
| 364 ScheduleTasks(); | |
| 365 | |
| 366 // Schedule another task to replace the still-pending task. Because the old | |
| 367 // task is not a throttled task in the new task set, it should not prevent | |
| 368 // DidFinishRunningTasks from getting signaled. | |
| 369 RasterTaskVector tasks; | |
| 370 tasks.swap(tasks_); | |
| 371 AppendTask(1u); | |
| 372 ScheduleTasks(); | |
| 373 | |
| 374 // Unblock the first task to allow the second task to complete. | |
| 375 lock.Release(); | |
| 376 | |
| 377 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 378 } | |
| 379 | |
| 380 TEST_P(RasterWorkerPoolTest, LargeResources) { | |
| 381 gfx::Size size(kLargeResourceDimension, kLargeResourceDimension); | |
| 382 | |
| 383 { | |
| 384 // Verify a resource of this size is larger than the transfer buffer. | |
| 385 scoped_ptr<ScopedResource> resource( | |
| 386 ScopedResource::Create(resource_provider_.get())); | |
| 387 resource->Allocate(size, ResourceProvider::TextureHintImmutable, RGBA_8888); | |
| 388 EXPECT_GE(resource->bytes(), kMaxTransferBufferUsageBytes); | |
| 389 } | |
| 390 | |
| 391 AppendTask(0u, size); | |
| 392 AppendTask(1u, size); | |
| 393 AppendTask(2u, size); | |
| 394 ScheduleTasks(); | |
| 395 | |
| 396 // This will time out if a resource that is larger than the throttle limit | |
| 397 // never gets scheduled. | |
| 398 RunMessageLoopUntilAllTasksHaveCompleted(); | |
| 399 } | |
| 400 | |
| 401 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests, | |
| 402 RasterWorkerPoolTest, | |
| 403 ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER, | |
| 404 RASTER_WORKER_POOL_TYPE_ZERO_COPY, | |
| 405 RASTER_WORKER_POOL_TYPE_ONE_COPY, | |
| 406 RASTER_WORKER_POOL_TYPE_GPU, | |
| 407 RASTER_WORKER_POOL_TYPE_BITMAP)); | |
| 408 | |
| 409 } // namespace | |
| 410 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 786583002:
cc: Renaming Rasterizer and RasterWorkerPool interfaces (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master