cc: Add new RasterWorkerPool interface.

cc/resources/image_raster_worker_pool.cc

Index: cc/resources/image_raster_worker_pool.cc
diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2e2b727455ada93863d354426385be675ab040fa
--- /dev/null
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -0,0 +1,135 @@
+// 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 "cc/resources/resource.h"
+#include "third_party/skia/include/core/SkDevice.h"
+
+namespace cc {
+
+namespace {
+
+class ImageWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+ public:
+  // First callback parameter is true when task was canceled.
+  typedef base::Callback<void(bool)> Reply;
+
+  ImageWorkerPoolTaskImpl(internal::RasterWorkerPoolTask* task,
+                          TaskVector* dependencies,
+                          uint8_t* buffer,
+                          int stride,
+                          const Reply& reply)
+      : internal::WorkerPoolTask(dependencies),
+        task_(task),
+        buffer_(buffer),
+        stride_(stride),
+        reply_(reply) {
+  }
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnThread(unsigned thread_index) OVERRIDE {
+    DCHECK(buffer_);
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                     task_->resource()->size().width(),
+                     task_->resource()->size().height(),
+                     stride_);
+    bitmap.setPixels(buffer_);
+    SkDevice device(bitmap);
+    task_->RunOnThread(&device, thread_index);
+  }
+  virtual void DispatchCompletionCallback() OVERRIDE {
+    reply_.Run(!HasFinishedRunning());
+  }
+
+ private:
+  virtual ~ImageWorkerPoolTaskImpl() {}
+
+  scoped_refptr<internal::RasterWorkerPoolTask> task_;
+  uint8_t* buffer_;
+  int stride_;
+  const Reply reply_;
+};
+
+}  // namespace
+
+ImageRasterWorkerPool::ImageRasterWorkerPool(
+    ResourceProvider* resource_provider, size_t num_threads)
+    : RasterWorkerPool(resource_provider, num_threads) {
+  // TODO(reveman): Remove WorkerPool client interface.
+  WorkerPool::SetClient(this);
+}
+
+ImageRasterWorkerPool::~ImageRasterWorkerPool() {
+  DCHECK_EQ(0u, image_tasks_.size());
+}
+
+void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
+  internal::WorkerPoolTask::TaskVector raster_tasks;
+
+  RasterWorkerPool::SetRasterTasks(queue);
+
+  for (RasterTask::Queue::TaskVector::iterator it = raster_tasks_.begin();
+       it != raster_tasks_.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = *it;
+
+    TaskMap::iterator image_it = image_tasks_.find(task);
+    if (image_it != image_tasks_.end()) {
+      internal::WorkerPoolTask* image_task = image_it->second;
+      raster_tasks.push_back(image_task);
+      continue;
+    }
+
+    // Acquire image for resource.
+    resource_provider_->AcquireImage(task->resource()->id());
+
+    // Map image for raster.
+    uint8* buffer = resource_provider_->MapImage(task->resource()->id());
+    int stride = resource_provider_->GetImageStride(task->resource()->id());
+
+    // TODO(reveman): Avoid having to make a copy of dependencies.
+    internal::WorkerPoolTask::TaskVector dependencies = task->dependencies();
+    scoped_refptr<internal::WorkerPoolTask> image_task(
+        new ImageWorkerPoolTaskImpl(
+            task,
+            &dependencies,
+            buffer,
+            stride,
+            base::Bind(&ImageRasterWorkerPool::OnRasterTaskCompleted,
+                       base::Unretained(this),
+                       make_scoped_refptr(task))));
+
+    image_tasks_[task] = image_task;
+    raster_tasks.push_back(image_task);
+  }
+
+  ScheduleRasterTasks(&raster_tasks);
+}
+
+void ImageRasterWorkerPool::OnRasterTaskCompleted(
+    scoped_refptr<internal::RasterWorkerPoolTask> task,
+    bool was_canceled) {
+  DCHECK(image_tasks_.find(task) != image_tasks_.end());
+
+  // Balanced with MapImage() call in ScheduleTasks().
+  resource_provider_->UnmapImage(task->resource()->id());
+
+  // Bind image to resource.
+  resource_provider_->BindImage(task->resource()->id());

[kaanb, 2013/05/30 18:48:36]

Should we still bind if the task was canceled?

[reveman, 2013/05/30 23:25:18]

this is essentially the same as the needs_bind condition I removed. we might
want to avoid the bind in these cases but lets wait and add that when we have
some data showing that this unnecessary bind is worth avoiding.

+
+  if (!was_canceled)
+    task->DidRun();
+
+  DidFinishRasterTask(task);
+  image_tasks_.erase(task);
+}
+
+void ImageRasterWorkerPool::DidFinishRasterTask(
+    internal::RasterWorkerPoolTask* task) {
+  task->DidComplete();
+  task->DispatchCompletionCallback();
+}
+
+}  // namespace cc