cc/resources/tile_task_worker_pool_unittest.cc

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