cc: Generalize raster task notifications

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 "base/cancelable_callback.h"
@@ skipping 91 matching lines @@
     : public testing::TestWithParam<RasterWorkerPoolType>,
       public RasterizerClient {
  public:
   struct RasterTaskResult {
     unsigned id;
     bool canceled;
   };
 
   typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
 
+  enum NamedTaskSet { REQUIRED_FOR_ACTIVATION = 0, ALL = 1 };
+
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
         timeout_seconds_(5),
         timed_out_(false) {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
@@ skipping 44 matching lines @@
     resource_provider_.reset();
   }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
     raster_worker_pool_->AsRasterizer()->Shutdown();
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterWorkerPoolClient:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
-      OVERRIDE {
-    return false;
+  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE {
+    if (task_set == ALL) {
+      raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
+      base::MessageLoop::current()->Quit();
+    }
   }
-  virtual void DidFinishRunningTasks() OVERRIDE {
-    raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
-    base::MessageLoop::current()->Quit();
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE {
+    return TaskSetCollection();
   }
-  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
 
   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();
 
     timeout_.Cancel();
 
     ASSERT_FALSE(timed_out_) << "Test timed out";
   }
 
   void ScheduleTasks() {
     RasterTaskQueue queue;
 
     for (RasterTaskVector::const_iterator it = tasks_.begin();
          it != tasks_.end();
-         ++it)
-      queue.items.push_back(RasterTaskQueue::Item(it->get(), false));
+         ++it) {
+      TaskSetCollection task_sets;
+      task_sets[ALL] = true;
+      queue.items.push_back(RasterTaskQueue::Item(it->get(), task_sets));
+    }
 
     raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
   }
 
   void AppendTask(unsigned id, const gfx::Size& size) {
     scoped_ptr<ScopedResource> resource(
         ScopedResource::Create(resource_provider_.get()));
     resource->Allocate(size, ResourceProvider::TextureHintImmutable, RGBA_8888);
     const Resource* const_resource = resource.get();
 
@@ skipping 135 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
                         RasterWorkerPoolTest,
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
                                           RASTER_WORKER_POOL_TYPE_IMAGE,
                                           RASTER_WORKER_POOL_TYPE_IMAGE_COPY,
                                           RASTER_WORKER_POOL_TYPE_GPU));
 
 }  // namespace
 }  // namespace cc