cc: Refactor and cleanup RasterWorkerPool unit tests.

cc/resources/raster_worker_pool_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/raster_worker_pool.h"
 
 #include <limits>
 #include <vector>
 
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
+enum RasterThread { NONE, ORIGIN, WORKER };

[alokp, 2014/01/27 08:09:19]

I prefer RASTER_THREAD prefix?

[reveman, 2014/01/27 16:03:20]

Done.

+
 class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
-  enum RasterThread {
-    RASTER_THREAD_NONE,
-    RASTER_THREAD_ORIGIN,
-    RASTER_THREAD_WORKER
-  };
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               RasterThread raster_thread)> Reply;
 
   TestRasterWorkerPoolTaskImpl(const Resource* resource,
                                const Reply& reply,
                                internal::Task::Vector* dependencies,
                                bool use_gpu_rasterization)
       : internal::RasterWorkerPoolTask(resource,
                                        dependencies,
                                        use_gpu_rasterization),
         reply_(reply),
-        raster_thread_(RASTER_THREAD_NONE) {}
+        raster_thread_(NONE) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
-    raster_thread_ = RASTER_THREAD_WORKER;
+    raster_thread_ = WORKER;
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPool* worker_pool)
       OVERRIDE {
     int stride;
     worker_pool->AcquireBufferForRaster(this, &stride);
   }
   virtual void CompleteOnOriginThread(internal::WorkerPool* worker_pool)
       OVERRIDE {
     worker_pool->OnRasterCompleted(this, PicturePileImpl::Analysis());
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(
         PicturePileImpl::Analysis(), !HasFinishedRunning(), raster_thread_);
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual void RunOnOriginThread(ResourceProvider* resource_provider,
                                  ContextProvider* context_provider) OVERRIDE {
-    raster_thread_ = RASTER_THREAD_ORIGIN;
+    raster_thread_ = ORIGIN;
   }
 
  protected:
   virtual ~TestRasterWorkerPoolTaskImpl() {}
 
  private:
   const Reply reply_;
   RasterThread raster_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
@@ skipping 23 matching lines @@
 
  protected:
   virtual ~BlockingRasterWorkerPoolTaskImpl() {}
 
  private:
   base::Lock* lock_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockingRasterWorkerPoolTaskImpl);
 };
 
-class RasterWorkerPoolTest : public testing::Test,
-                             public RasterWorkerPoolClient {
+enum RasterWorkerPoolType { PIXEL_BUFFER, IMAGE };
+
+class RasterWorkerPoolTest
+    : public testing::TestWithParam<RasterWorkerPoolType>,
+      public RasterWorkerPoolClient {
  public:
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
-        check_interval_milliseconds_(1),
         timeout_seconds_(5),
         timed_out_(false) {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     resource_provider_ = ResourceProvider::Create(
                              output_surface_.get(), NULL, 0, false, 1).Pass();
+
+    switch (GetParam()) {
+      case IMAGE:
+        raster_worker_pool_ = ImageRasterWorkerPool::Create(
+            resource_provider_.get(), context_provider_.get(), GL_TEXTURE_2D);
+        break;
+      case PIXEL_BUFFER:
+        raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
+            resource_provider_.get(),
+            context_provider_.get(),
+            std::numeric_limits<size_t>::max());
+        break;
+    }
+
+    DCHECK(raster_worker_pool_);
+    raster_worker_pool_->SetClient(this);
   }
   virtual ~RasterWorkerPoolTest() { resource_provider_.reset(); }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
-    if (!raster_worker_pool_)
-      return;
     raster_worker_pool_->Shutdown();
     raster_worker_pool_->CheckForCompletedTasks();
   }
 
   // Overriden from RasterWorkerPoolClient:
   virtual bool ShouldForceTasksRequiredForActivationToComplete()
       const OVERRIDE {
     return false;
   }
-  virtual void DidFinishRunningTasks() OVERRIDE {}
+  virtual void DidFinishRunningTasks() OVERRIDE {
+    raster_worker_pool_->CheckForCompletedTasks();
+    base::MessageLoop::current()->Quit();
+  }
   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
 
-  virtual void BeginTest() = 0;
-  virtual void AfterTest() = 0;
-
-  ResourceProvider* resource_provider() const {
-    return resource_provider_.get();
-  }
-
-  RasterWorkerPool* worker_pool() { return raster_worker_pool_.get(); }
-
-  void RunTest(bool use_map_image) {
-    if (use_map_image) {
-      raster_worker_pool_ = ImageRasterWorkerPool::Create(
-          resource_provider(), context_provider_.get(), GL_TEXTURE_2D);
-    } else {
-      raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
-          resource_provider(),
-          context_provider_.get(),
-          std::numeric_limits<size_t>::max());
-    }
-
-    raster_worker_pool_->SetClient(this);
-
-    BeginTest();
-
-    ScheduleCheckForCompletedTasks();
-
+  void RunMessageLoopUntilAllTasksHaveCompleted() {
     if (timeout_seconds_) {
       timeout_.Reset(
           base::Bind(&RasterWorkerPoolTest::OnTimeout, base::Unretained(this)));
       base::MessageLoopProxy::current()->PostDelayedTask(
           FROM_HERE,
           timeout_.callback(),
           base::TimeDelta::FromSeconds(timeout_seconds_));
     }
 
     base::MessageLoop::current()->Run();
 
-    check_.Cancel();
     timeout_.Cancel();
 
-    if (timed_out_) {
-      FAIL() << "Test timed out";
-      return;
-    }
-    AfterTest();
+    ASSERT_FALSE(timed_out_) << "Test timed out";
   }
 
-  void EndTest() { base::MessageLoop::current()->Quit(); }
-
   void ScheduleTasks() {
     RasterWorkerPool::RasterTask::Queue tasks;
 
     for (std::vector<RasterWorkerPool::RasterTask>::iterator it =
              tasks_.begin();
          it != tasks_.end();
          ++it)
       tasks.Append(*it, false);
 
-    worker_pool()->ScheduleTasks(&tasks);
+    raster_worker_pool_->ScheduleTasks(&tasks);
   }
 
   void AppendTask(unsigned id, bool use_gpu_rasterization) {
     const gfx::Size size(1, 1);
 
     scoped_ptr<ScopedResource> resource(
-        ScopedResource::Create(resource_provider()));
+        ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
     RasterWorkerPool::Task::Set empty;
     tasks_.push_back(
         RasterWorkerPool::RasterTask(new TestRasterWorkerPoolTaskImpl(
             const_resource,
             base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                        base::Unretained(this),
                        base::Passed(&resource),
                        id),
             &empty.tasks_,
             use_gpu_rasterization)));
   }
 
   void AppendBlockingTask(unsigned id, base::Lock* lock) {
     const gfx::Size size(1, 1);
 
     scoped_ptr<ScopedResource> resource(
-        ScopedResource::Create(resource_provider()));
+        ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
     RasterWorkerPool::Task::Set empty;
     tasks_.push_back(
         RasterWorkerPool::RasterTask(new BlockingRasterWorkerPoolTaskImpl(
             const_resource,
             base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                        base::Unretained(this),
                        base::Passed(&resource),
                        id),
             lock,
             &empty.tasks_,
             false)));
   }
 
-  virtual void OnTaskCompleted(
-      scoped_ptr<ScopedResource> resource,
-      unsigned id,
-      const PicturePileImpl::Analysis& analysis,
-      bool was_canceled,
-      TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) {}
+  const std::vector<unsigned>& completed_task_ids() const {
+    return completed_task_ids_;
+  }
+
+  const std::vector<bool>& completed_task_cancellation_values() const {
+    return completed_task_cancellation_values_;
+  }
+
+  const std::vector<RasterThread>& completed_task_raster_threads() const {
+    return completed_task_raster_threads_;
+  }
 
  private:
-  void ScheduleCheckForCompletedTasks() {
-    check_.Reset(base::Bind(&RasterWorkerPoolTest::OnCheckForCompletedTasks,
-                            base::Unretained(this)));
-    base::MessageLoopProxy::current()->PostDelayedTask(
-        FROM_HERE,
-        check_.callback(),
-        base::TimeDelta::FromMilliseconds(check_interval_milliseconds_));
-  }
-
-  void OnCheckForCompletedTasks() {
-    raster_worker_pool_->CheckForCompletedTasks();
-    ScheduleCheckForCompletedTasks();
+  void OnTaskCompleted(scoped_ptr<ScopedResource> resource,
+                       unsigned id,
+                       const PicturePileImpl::Analysis& analysis,
+                       bool was_canceled,
+                       RasterThread raster_thread) {
+    completed_task_ids_.push_back(id);
+    completed_task_cancellation_values_.push_back(was_canceled);
+    completed_task_raster_threads_.push_back(raster_thread);
   }
 
   void OnTimeout() {
     timed_out_ = true;
     base::MessageLoop::current()->Quit();
   }
 
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
-  base::CancelableClosure check_;
-  int check_interval_milliseconds_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;
   std::vector<RasterWorkerPool::RasterTask> tasks_;
+  std::vector<unsigned> completed_task_ids_;

[alokp, 2014/01/27 08:09:19]

It may be better to store a single vector of structs. Each struct will store id,
cancellation, and raster thread.

[reveman, 2014/01/27 16:03:20]

Done.

+  std::vector<bool> completed_task_cancellation_values_;
+  std::vector<RasterThread> completed_task_raster_threads_;
 };
 
 namespace {
 
-#define PIXEL_BUFFER_TEST_F(TEST_FIXTURE_NAME) \
-  TEST_F(TEST_FIXTURE_NAME, RunPixelBuffer) { RunTest(false); }
+TEST_P(RasterWorkerPoolTest, Basic) {
+  AppendTask(0u, false);
+  AppendTask(1u, false);
+  ScheduleTasks();
 
-#define IMAGE_TEST_F(TEST_FIXTURE_NAME) \
-  TEST_F(TEST_FIXTURE_NAME, RunImage) { RunTest(true); }
+  RunMessageLoopUntilAllTasksHaveCompleted();
 
-#define PIXEL_BUFFER_AND_IMAGE_TEST_F(TEST_FIXTURE_NAME) \
-  PIXEL_BUFFER_TEST_F(TEST_FIXTURE_NAME);                \
-  IMAGE_TEST_F(TEST_FIXTURE_NAME)
+  ASSERT_EQ(2u, completed_task_ids().size());
+  EXPECT_FALSE(completed_task_cancellation_values()[0]);
+  EXPECT_FALSE(completed_task_cancellation_values()[1]);
+  EXPECT_EQ(WORKER, completed_task_raster_threads()[0]);
+  EXPECT_EQ(WORKER, completed_task_raster_threads()[1]);
+}
 
-class RasterWorkerPoolTestSofwareRaster : public RasterWorkerPoolTest {
- public:
-  virtual void OnTaskCompleted(
-      scoped_ptr<ScopedResource> resource,
-      unsigned id,
-      const PicturePileImpl::Analysis& analysis,
-      bool was_canceled,
-      TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) OVERRIDE {
-    EXPECT_FALSE(was_canceled);
-    EXPECT_EQ(TestRasterWorkerPoolTaskImpl::RASTER_THREAD_WORKER,
-              raster_thread);
-    on_task_completed_ids_.push_back(id);
-    if (on_task_completed_ids_.size() == 2)
-      EndTest();
-  }
+TEST_P(RasterWorkerPoolTest, GpuRaster) {
+  AppendTask(0u, true);  // GPU raster.
+  ScheduleTasks();
 
-  // Overridden from RasterWorkerPoolTest:
-  virtual void BeginTest() OVERRIDE {
-    AppendTask(0u, false);
-    AppendTask(1u, false);
-    ScheduleTasks();
-  }
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(2u, on_task_completed_ids_.size());
-    tasks_.clear();
-  }
+  RunMessageLoopUntilAllTasksHaveCompleted();
 
-  std::vector<unsigned> on_task_completed_ids_;
-};
+  ASSERT_EQ(1u, completed_task_ids().size());
+  EXPECT_EQ(0u, completed_task_ids()[0]);
+  EXPECT_FALSE(completed_task_cancellation_values()[0]);
+  EXPECT_EQ(ORIGIN, completed_task_raster_threads()[0]);
+}
 
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestSofwareRaster);
+TEST_P(RasterWorkerPoolTest, HybridRaster) {
+  AppendTask(0u, false);  // Software raster.
+  AppendTask(1u, true);   // GPU raster.
+  ScheduleTasks();
 
-class RasterWorkerPoolTestGpuRaster : public RasterWorkerPoolTest {
- public:
-  virtual void OnTaskCompleted(
-      scoped_ptr<ScopedResource> resource,
-      unsigned id,
-      const PicturePileImpl::Analysis& analysis,
-      bool was_canceled,
-      TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) OVERRIDE {
-    EXPECT_EQ(0u, id);
-    EXPECT_FALSE(was_canceled);
-    EXPECT_EQ(TestRasterWorkerPoolTaskImpl::RASTER_THREAD_ORIGIN,
-              raster_thread);
-    EndTest();
-  }
+  RunMessageLoopUntilAllTasksHaveCompleted();
 
-  // Overridden from RasterWorkerPoolTest:
-  virtual void BeginTest() OVERRIDE {
-    AppendTask(0u, true);  // GPU raster.
-    ScheduleTasks();
-  }
-
-  virtual void AfterTest() OVERRIDE { EXPECT_EQ(1u, tasks_.size()); }
-};
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestGpuRaster);
-
-class RasterWorkerPoolTestHybridRaster : public RasterWorkerPoolTest {
- public:
-  virtual void OnTaskCompleted(
-      scoped_ptr<ScopedResource> resource,
-      unsigned id,
-      const PicturePileImpl::Analysis& analysis,
-      bool was_canceled,
-      TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) OVERRIDE {
-    EXPECT_FALSE(was_canceled);
-    switch (id) {
+  ASSERT_EQ(2u, completed_task_ids().size());
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_FALSE(completed_task_cancellation_values()[i]);
+    switch (completed_task_ids()[i]) {
       case 0u:
-        EXPECT_EQ(TestRasterWorkerPoolTaskImpl::RASTER_THREAD_WORKER,
-                  raster_thread);
+        EXPECT_EQ(WORKER, completed_task_raster_threads()[i]);
         break;
       case 1u:
-        EXPECT_EQ(TestRasterWorkerPoolTaskImpl::RASTER_THREAD_ORIGIN,
-                  raster_thread);
+        EXPECT_EQ(ORIGIN, completed_task_raster_threads()[i]);
         break;
       default:
         NOTREACHED();
     }
-    completed_task_ids_.push_back(id);
-    if (completed_task_ids_.size() == 2)
-      EndTest();
   }
+}
 
-  // Overridden from RasterWorkerPoolTest:
-  virtual void BeginTest() OVERRIDE {
-    AppendTask(0u, false);  // Software raster.
-    AppendTask(1u, true);   // GPU raster.
-    ScheduleTasks();
-  }
+TEST_P(RasterWorkerPoolTest, FailedMapResource) {
+  TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
+  context3d->set_times_map_image_chromium_succeeds(0);
+  context3d->set_times_map_buffer_chromium_succeeds(0);
+  AppendTask(0u, false);
+  ScheduleTasks();
 
-  virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(2u, tasks_.size());
-    EXPECT_EQ(2u, completed_task_ids_.size());
-  }
+  RunMessageLoopUntilAllTasksHaveCompleted();
 
-  std::vector<unsigned> completed_task_ids_;
-};
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestHybridRaster);
+  ASSERT_EQ(1u, completed_task_ids().size());
+  EXPECT_FALSE(completed_task_cancellation_values()[0]);
+  EXPECT_EQ(WORKER, completed_task_raster_threads()[0]);
+}
 
-class RasterWorkerPoolTestFailedMapResource : public RasterWorkerPoolTest {
- public:
-  virtual void OnTaskCompleted(
-      scoped_ptr<ScopedResource> resource,
-      unsigned id,
-      const PicturePileImpl::Analysis& analysis,
-      bool was_canceled,
-      TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) OVERRIDE {
-    EXPECT_FALSE(was_canceled);
-    EXPECT_EQ(TestRasterWorkerPoolTaskImpl::RASTER_THREAD_WORKER,
-              raster_thread);
-    EndTest();
-  }
+// This test checks that replacing a pending raster task with another does
+// not prevent the DidFinishRunningTasks notification from being sent.
+TEST_P(RasterWorkerPoolTest, FalseThrottling) {
+  base::Lock lock;
 
-  // Overridden from RasterWorkerPoolTest:
-  virtual void BeginTest() OVERRIDE {
-    TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
-    context3d->set_times_map_image_chromium_succeeds(0);
-    context3d->set_times_map_buffer_chromium_succeeds(0);
-    AppendTask(0u, false);
-    ScheduleTasks();
-  }
+  // Schedule a task that is prevented from completing with a lock.
+  lock.Acquire();
+  AppendBlockingTask(0u, &lock);
+  ScheduleTasks();
 
-  virtual void AfterTest() OVERRIDE {
-    ASSERT_EQ(1u, tasks_.size());
-    tasks_.clear();
-  }
-};
+  // Schedule another task to replace the still-pending task. Because the old
+  // task is not a throttled task in the new task set, it should not prevent
+  // DidFinishRunningTasks from getting signaled.
+  tasks_.clear();
+  AppendTask(1u, false);
+  ScheduleTasks();
 
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFailedMapResource);
+  // Unblock the first task to allow the second task to complete.
+  lock.Release();
 
-class RasterWorkerPoolTestFalseThrottling : public RasterWorkerPoolTest {
- public:
-  // Overridden from RasterWorkerPoolTest:
-  virtual void BeginTest() OVERRIDE {
-    // This test checks that replacing a pending raster task with another does
-    // not prevent the DidFinishRunningTasks notification from being sent.
+  RunMessageLoopUntilAllTasksHaveCompleted();
+}
 
-    // Schedule a task that is prevented from completing with a lock.
-    lock_.Acquire();
-    AppendBlockingTask(0u, &lock_);
-    ScheduleTasks();
-
-    // Schedule another task to replace the still-pending task. Because the old
-    // task is not a throttled task in the new task set, it should not prevent
-    // DidFinishRunningTasks from getting signaled.
-    tasks_.clear();
-    AppendTask(1u, false);
-    ScheduleTasks();
-
-    // Unblock the first task to allow the second task to complete.
-    lock_.Release();
-  }
-
-  virtual void AfterTest() OVERRIDE {}
-
-  virtual void DidFinishRunningTasks() OVERRIDE { EndTest(); }
-
-  base::Lock lock_;
-};
-
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFalseThrottling);
+INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
+                        RasterWorkerPoolTest,
+                        ::testing::Values(PIXEL_BUFFER, IMAGE));
 
 }  // namespace
 }  // namespace cc