cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/direct_raster_worker_pool.cc

+// Copyright 2014 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/direct_raster_worker_pool.h"
+
+#include "cc/output/context_provider.h"
+#include "cc/resources/resource.h"
+#include "cc/resources/resource_provider.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+
+namespace cc {
+
+// static
+scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
+    ResourceProvider* resource_provider,
+    ContextProvider* context_provider) {
+  return make_scoped_ptr<RasterWorkerPool>(
+      new DirectRasterWorkerPool(resource_provider, context_provider));
+}
+
+DirectRasterWorkerPool::DirectRasterWorkerPool(
+    ResourceProvider* resource_provider,
+    ContextProvider* context_provider)
+    : RasterWorkerPool(NULL, resource_provider),
+      context_provider_(context_provider),
+      run_tasks_on_origin_thread_pending_(false),
+      raster_tasks_pending_(false),
+      raster_tasks_required_for_activation_pending_(false),
+      weak_factory_(this) {}
+
+DirectRasterWorkerPool::~DirectRasterWorkerPool() {
+  DCHECK_EQ(0u, completed_tasks_.size());
+}
+
+void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {

[reveman, 2014/02/14 16:11:53]

Technically this needs to cancel tasks that have not yet run. I'll fix this.

FYI, the need to do this will be removed in the follow up patch that makes
TileVersion a Task as that allows resources to only be pinned to tiles between
::ScheduleTileOnOriginThread/::CompleteTileOnOriginThread.

[reveman, 2014/02/14 23:30:52]

Done.

+  TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks");
+
+  DCHECK_EQ(queue->required_for_activation_count,
+            static_cast<size_t>(
+                std::count_if(queue->tasks.begin(),
+                              queue->tasks.end(),
+                              RasterTaskQueue::Task::IsRequiredForActivation)));
+
+  raster_tasks_pending_ = true;
+  raster_tasks_required_for_activation_pending_ = true;
+
+  scoped_refptr<internal::WorkerPoolTask>
+      new_raster_required_for_activation_finished_task(
+          CreateRasterRequiredForActivationFinishedTask(
+              queue->required_for_activation_count));
+  scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
+      CreateRasterFinishedTask());
+
+  ScheduleRunTasksOnOriginThread();
+
+  raster_tasks_.Swap(queue);
+
+  set_raster_finished_task(new_raster_finished_task);
+  set_raster_required_for_activation_finished_task(
+      new_raster_required_for_activation_finished_task);
+}
+
+unsigned DirectRasterWorkerPool::GetResourceTarget() const {
+  return GL_TEXTURE_2D;
+}
+
+ResourceFormat DirectRasterWorkerPool::GetResourceFormat() const {
+  return resource_provider()->best_texture_format();
+}
+
+void DirectRasterWorkerPool::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
+
+  for (internal::WorkerPoolTask::Vector::const_iterator it =
+           completed_tasks_.begin();
+       it != completed_tasks_.end();
+       ++it) {
+    internal::WorkerPoolTask* task = it->get();
+
+    task->RunReplyOnOriginThread();
+  }
+  completed_tasks_.clear();
+}
+
+SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(
+    internal::RasterWorkerPoolTask* task) {
+  return resource_provider()->MapDirectRasterBuffer(task->resource()->id());
+}
+
+void DirectRasterWorkerPool::OnRasterCompleted(
+    internal::RasterWorkerPoolTask* task,
+    const PicturePileImpl::Analysis& analysis) {
+  resource_provider()->UnmapDirectRasterBuffer(task->resource()->id());
+}
+
+void DirectRasterWorkerPool::OnRasterTasksFinished() {
+  DCHECK(raster_tasks_pending_);
+  raster_tasks_pending_ = false;
+  client()->DidFinishRunningTasks();
+}
+
+void DirectRasterWorkerPool::OnRasterTasksRequiredForActivationFinished() {
+  DCHECK(raster_tasks_required_for_activation_pending_);
+  raster_tasks_required_for_activation_pending_ = false;
+  client()->DidFinishRunningTasksRequiredForActivation();
+}
+
+void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
+  if (run_tasks_on_origin_thread_pending_)
+    return;
+
+  base::MessageLoopProxy::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread,
+                 weak_factory_.GetWeakPtr()));
+  run_tasks_on_origin_thread_pending_ = true;
+}
+
+void DirectRasterWorkerPool::RunTasksOnOriginThread() {
+  DCHECK(run_tasks_on_origin_thread_pending_);
+  run_tasks_on_origin_thread_pending_ = false;
+
+  if (!raster_tasks_.tasks.empty()) {
+    GrContext* gr_context = context_provider_->GrContext();
+    // TODO(alokp): Implement TestContextProvider::GrContext().
+    if (gr_context)
+      gr_context->resetContext();
+
+    for (RasterTaskQueueIterator it(&raster_tasks_); it; ++it) {
+      internal::RasterWorkerPoolTask* task = *it;
+      DCHECK(!task->HasCompleted());
+
+      // TODO(reveman): Run image decode tasks on origin thread.
+      DCHECK_EQ(0u, task->dependencies().size());

[reveman, 2014/02/14 23:30:52]

Turned out this needs to be implement for unit and perf tests to work. I think
that's the correct thing to do though. Makes everything a bit more consistent.

+
+      RunTaskOnOriginThread(task);
+
+      completed_tasks_.push_back(task);
+    }
+
+    // TODO(alokp): Implement TestContextProvider::GrContext().
+    if (gr_context)
+      gr_context->flush();
+  }
+
+  RunTaskOnOriginThread(raster_finished_task());
+  RunTaskOnOriginThread(raster_required_for_activation_finished_task());

[alokp, 2014/02/14 18:50:59]

shouldn't activation-finished be run before raster-finished?

[reveman, 2014/02/14 23:30:52]

Good point. Done. This is not currently required but generally a good idea.
Maybe we should have it be required. Just need to make raster-finished a
dependent of raster-required-for-activation-finished in the multi-threaded
case...

+}
+
+}  // namespace cc