Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(718)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/resources/raster_worker_pool_unittest.cc

Issue 143693007: cc: Refactor and cleanup RasterWorkerPool unit tests. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/resources/raster_worker_pool_unittest.cc
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index 8aa63744ee6e5e8c06a0eef61fc5fe197c159e04..385b2b16cee9a42594e9e15404f3de981c389d70 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -20,13 +20,10 @@
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;
@@ -39,11 +36,11 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
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:
@@ -64,7 +61,7 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
// Overridden from internal::RasterWorkerPoolTask:
virtual void RunOnOriginThread(ResourceProvider* resource_provider,
ContextProvider* context_provider) OVERRIDE {
- raster_thread_ = RASTER_THREAD_ORIGIN;
+ raster_thread_ = ORIGIN;
}
protected:
@@ -108,12 +105,14 @@ class BlockingRasterWorkerPoolTaskImpl : public TestRasterWorkerPoolTaskImpl {
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();
@@ -121,13 +120,27 @@ class RasterWorkerPoolTest : public testing::Test,
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();
}
@@ -137,35 +150,13 @@ class RasterWorkerPoolTest : public testing::Test,
const OVERRIDE {
return false;
}
- virtual void DidFinishRunningTasks() OVERRIDE {}
- virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
-
- virtual void BeginTest() = 0;
- virtual void AfterTest() = 0;
-
- ResourceProvider* resource_provider() const {
- return resource_provider_.get();
+ virtual void DidFinishRunningTasks() OVERRIDE {
+ raster_worker_pool_->CheckForCompletedTasks();
+ base::MessageLoop::current()->Quit();
}
+ virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
- 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)));
@@ -177,18 +168,11 @@ class RasterWorkerPoolTest : public testing::Test,
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;
@@ -198,14 +182,14 @@ class RasterWorkerPoolTest : public testing::Test,
++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();
@@ -225,7 +209,7 @@ class RasterWorkerPoolTest : public testing::Test,
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();
@@ -242,26 +226,27 @@ class RasterWorkerPoolTest : public testing::Test,
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_;
+ }
- 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_));
+ const std::vector<bool>& completed_task_cancellation_values() const {
+ return completed_task_cancellation_values_;
}
- void OnCheckForCompletedTasks() {
- raster_worker_pool_->CheckForCompletedTasks();
- ScheduleCheckForCompletedTasks();
+ const std::vector<RasterThread>& completed_task_raster_threads() const {
+ return completed_task_raster_threads_;
+ }
+
+ private:
+ 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() {
@@ -275,187 +260,106 @@ class RasterWorkerPoolTest : public testing::Test,
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 struc
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();
- }
-
- // Overridden from RasterWorkerPoolTest:
- virtual void BeginTest() OVERRIDE {
- AppendTask(0u, true); // GPU raster.
- ScheduleTasks();
- }
+ RunMessageLoopUntilAllTasksHaveCompleted();
- 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();
- }
-
- virtual void AfterTest() OVERRIDE {
- EXPECT_EQ(2u, tasks_.size());
- EXPECT_EQ(2u, completed_task_ids_.size());
- }
-
- std::vector<unsigned> completed_task_ids_;
-};
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestHybridRaster);
-
-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();
- }
-
- // 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();
- }
-
- virtual void AfterTest() OVERRIDE {
- ASSERT_EQ(1u, tasks_.size());
- tasks_.clear();
- }
-};
-
-PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFailedMapResource);
-
-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.
-
- // 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);
+}
+
+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();
+
+ RunMessageLoopUntilAllTasksHaveCompleted();
+
+ ASSERT_EQ(1u, completed_task_ids().size());
+ EXPECT_FALSE(completed_task_cancellation_values()[0]);
+ EXPECT_EQ(WORKER, completed_task_raster_threads()[0]);
+}
+
+// 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;
+
+ // 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();
+
+ RunMessageLoopUntilAllTasksHaveCompleted();
+}
+
+INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
+ RasterWorkerPoolTest,
+ ::testing::Values(PIXEL_BUFFER, IMAGE));
} // namespace
} // namespace cc
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698