cc: Generalize raster task notifications

cc/resources/raster_worker_pool_perftest.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 "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_provider.h"
@@ skipping 129 matching lines @@
  private:
   scoped_ptr<ScopedResource> resource_;
 
   DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
 };
 
 class RasterWorkerPoolPerfTestBase {
  public:
   typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
 
+  enum NamedTaskSet { REQUIRED_FOR_ACTIVATION = 0, ALL = 1 };
+
   RasterWorkerPoolPerfTestBase()
       : context_provider_(make_scoped_refptr(new PerfContextProvider)),
         task_runner_(new base::TestSimpleTaskRunner),
         task_graph_runner_(new TaskGraphRunner),
         timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
                kTimeCheckInterval) {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
@@ skipping 29 matching lines @@
       ImageDecodeTask::Vector dependencies = image_decode_tasks;
       raster_tasks->push_back(
           new PerfRasterTaskImpl(resource.Pass(), &dependencies));
     }
   }
 
   void BuildRasterTaskQueue(RasterTaskQueue* queue,
                             const RasterTaskVector& raster_tasks) {
     for (size_t i = 0u; i < raster_tasks.size(); ++i) {
       bool required_for_activation = (i % 2) == 0;
-      queue->items.push_back(RasterTaskQueue::Item(raster_tasks[i].get(),
-                                                   required_for_activation));
+      TaskSetCollection task_set_collection;
+      task_set_collection[ALL] = true;
+      task_set_collection[REQUIRED_FOR_ACTIVATION] = required_for_activation;
+      queue->items.push_back(
+          RasterTaskQueue::Item(raster_tasks[i].get(), task_set_collection));
     }
   }
 
  protected:
   scoped_refptr<ContextProvider> context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourcePool> staging_resource_pool_;
@@ skipping 43 matching lines @@
     raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
     raster_worker_pool_->AsRasterizer()->Shutdown();
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterizerClient:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
-      OVERRIDE {
-    return false;
-  }
-  virtual void DidFinishRunningTasks() OVERRIDE {
+  virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE {
     raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
-  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
+  virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE {
+    return TaskSetCollection();
+  }
 
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     task_graph_runner_->RunUntilIdle();
     task_runner_->RunUntilIdle();
   }
 
   void RunScheduleTasksTest(const std::string& test_name,
                             unsigned num_raster_tasks,
                             unsigned num_image_decode_tasks) {
     ImageDecodeTask::Vector image_decode_tasks;
@@ skipping 182 matching lines @@
   RunBuildRasterTaskQueueTest("1_0", 1, 0);
   RunBuildRasterTaskQueueTest("32_0", 32, 0);
   RunBuildRasterTaskQueueTest("1_1", 1, 1);
   RunBuildRasterTaskQueueTest("32_1", 32, 1);
   RunBuildRasterTaskQueueTest("1_4", 1, 4);
   RunBuildRasterTaskQueueTest("32_4", 32, 4);
 }
 
 }  // namespace
 }  // namespace cc