Add preliminary support for hw-accelerated tile rasterization.

cc/resources/image_raster_worker_pool.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/image_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 
 namespace cc {
 
 namespace {
 
 class ImageWorkerPoolTaskImpl : public internal::WorkerPoolTask {

[reveman, 2013/12/17 23:03:16]

FYI, you can exercise this RasterWorkerPool impl on desktop using
--enable-map-image

[alokp, 2013/12/17 23:26:08]

does it work on windows?

[reveman, 2013/12/18 00:09:51]

It should. If it doesn't, please file a bug. It should also work with the
software compositor.

  public:
   typedef base::Callback<void(bool was_canceled)> Reply;
 
   ImageWorkerPoolTaskImpl(internal::RasterWorkerPoolTask* task,
                           uint8_t* buffer,
                           int stride,
                           const Reply& reply)
       : task_(task),
         buffer_(buffer),
         stride_(stride),
@@ skipping 23 matching lines @@
   int stride_;
   const Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageWorkerPoolTaskImpl);
 };
 
 }  // namespace
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_threads,
     GLenum texture_target)
-    : RasterWorkerPool(resource_provider, num_threads),
+    : RasterWorkerPool(resource_provider, context_provider, num_threads),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {
 }
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {
   DCHECK_EQ(0u, image_tasks_.size());
 }
 
 void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
@@ skipping 19 matching lines @@
           priority++,
           &graph);
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
       CreateRasterFinishedTask());
   internal::GraphNode* raster_finished_node =
       CreateGraphNodeForTask(new_raster_finished_task.get(),
                              priority++,
                              &graph);
 
+  RasterTaskVector gpu_rasterization_tasks;
+
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(!task->HasCompleted());
     DCHECK(!task->WasCanceled());
 
+    if (task->use_gpu_rasterization()) {
+      gpu_rasterization_tasks.push_back(task);
+      continue;
+    }
+
     TaskMap::iterator image_it = image_tasks_.find(task);
     if (image_it != image_tasks_.end()) {
       internal::WorkerPoolTask* image_task = image_it->second.get();
       CreateGraphNodeForImageTask(
           image_task,
           task->dependencies(),
           priority++,
           IsRasterTaskRequiredForActivation(task),
           raster_required_for_activation_finished_node,
           raster_finished_node,
@@ skipping 26 matching lines @@
         raster_finished_node,
         &graph);
   }
 
   SetTaskGraph(&graph);
 
   set_raster_finished_task(new_raster_finished_task);
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
+   // Run raster tasks that use GPU on impl thread.
+  RasterWorkerPool::RunGpuRasterizationTasks(gpu_rasterization_tasks);

[reveman, 2013/12/17 23:03:16]

RasterWorkerPool:: suffix unnecessary. Move comment to header.

[alokp, 2013/12/18 22:49:22]

Done.

+  for (RasterTaskVector::iterator it = gpu_rasterization_tasks.begin();
+      it != gpu_rasterization_tasks.end(); ++it) {
+    OnRasterTaskCompleted(*it, false);
+  }

[reveman, 2013/12/17 23:03:16]

You'll have to implement CheckForCompletedTasks and run these callbacks at that
time.

[alokp, 2013/12/17 23:26:08]

I am confused. Do you mean implement RasterWorkerPool::CheckForCompletedTasks?
Where is it called in ImageRasterWorkerPool? How would
Image/PixelBufferRasterWorkerPool be notified of completed raster tasks without
a callback? The callback is only registered for tasks in the task-graph.

[reveman, 2013/12/18 00:09:51]

As discussed offline. TileManager calls RasterWorkerPool::CheckForCompletedTasks
and expects callbacks to only run at that time.

[alokp, 2013/12/18 22:49:22]

Done.

+
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, "rasterizing",
       "state", TracedValue::FromValue(StateAsValue().release()));
 }
 
 GLenum ImageRasterWorkerPool::GetResourceTarget() const {
   return texture_target_;
 }
 
 ResourceFormat ImageRasterWorkerPool::GetResourceFormat() const {
@@ skipping 15 matching lines @@
       "state", TracedValue::FromValue(StateAsValue().release()));
   client()->DidFinishRunningTasksRequiredForActivation();
 }
 
 void ImageRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
     bool was_canceled) {
   TRACE_EVENT1("cc", "ImageRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
-  DCHECK(image_tasks_.find(task.get()) != image_tasks_.end());
-
-  // Balanced with MapImage() call in ScheduleTasks().
-  resource_provider()->UnmapImage(task->resource()->id());
+  if (task->use_gpu_rasterization()) {

[reveman, 2013/12/17 23:03:16]

Hm, as you're not running gpu raster in the thread pool can't this just be
DCHECK(!task->use_gpu_rasterization())?

[alokp, 2013/12/17 23:26:08]

Sorry. I am confused. Are you suggesting not calling
ImageRasterWorkerPool::OnRasterTaskCompleted for gpu-raster tasks?

[reveman, 2013/12/18 00:09:51]

I missed that you were calling this function directly from
ImageRasterWorkerPool::ScheduleTasks. I don't think you should do this as it's
meant for tasks that run on worker threads. You can instead handle completion of
gpu tasks separately in a similar way to how you're already doing this for
PBRWP.

[alokp, 2013/12/18 22:49:22]

Done.

+    // GPU rasterization tasks are not wrapped into image tasks.
+    DCHECK(image_tasks_.find(task.get()) == image_tasks_.end());
+  } else {
+    DCHECK(image_tasks_.find(task.get()) != image_tasks_.end());
+    // Balanced with MapImage() call in ScheduleTasks().
+    resource_provider()->UnmapImage(task->resource()->id());
+    image_tasks_.erase(task.get());
+  }
 
   task->DidRun(was_canceled);
   task->WillComplete();
   task->CompleteOnOriginThread();
   task->DidComplete();
-
-  image_tasks_.erase(task.get());
 }
 
 scoped_ptr<base::Value> ImageRasterWorkerPool::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
   state->Set("scheduled_state", ScheduledStateAsValue().release());
   return state.PassAs<base::Value>();
 }
@@ skipping 15 matching lines @@
   if (is_required_for_activation) {
     raster_required_for_activation_finished_node->add_dependency();
     image_node->add_dependent(raster_required_for_activation_finished_node);
   }
 
   raster_finished_node->add_dependency();
   image_node->add_dependent(raster_finished_node);
 }
 
 }  // namespace cc