Added preliminary support for tile rasterization with Ganesh

cc/resources/gpu_rasterizer.cc

Index: cc/resources/gpu_rasterizer.cc
diff --git a/cc/resources/gpu_rasterizer.cc b/cc/resources/gpu_rasterizer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..af194e47630dd7f7c08cb30cc203303af40fda72
--- /dev/null
+++ b/cc/resources/gpu_rasterizer.cc
@@ -0,0 +1,126 @@
+// 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/gpu_rasterizer.h"
+
+#include "base/logging.h"
+#include "cc/output/context_provider.h"
+#include "cc/resources/resource_format.h"
+#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/SkGpuDevice.h"
+#include "ui/gfx/size_conversions.h"
+
+namespace cc {
+
+namespace {
+
+GrPixelConfig toGrFormat(ResourceFormat format) {
+  switch (format) {
+    case RGBA_8888:
+      return kRGBA_8888_GrPixelConfig;
+    case BGRA_8888:
+      return kBGRA_8888_GrPixelConfig;
+    case RGBA_4444:
+      return kRGBA_4444_GrPixelConfig;
+    default:
+      break;  // If you break here, you're gonna have a bad time.
+  }
+  DCHECK(false) << "Unsupported resource format.";
+  return kSkia8888_GrPixelConfig;
+}
+
+}   // namespace
+
+GpuRasterizer::RasterTask::RasterTask(
+    Tile* tile, scoped_ptr<ResourcePool::Resource> resource)
+    : tile_(tile), resource_(resource.Pass()) {
+}
+
+GpuRasterizer::RasterTask::~RasterTask() {
+}
+
+scoped_ptr<GpuRasterizer> GpuRasterizer::Create(
+    ContextProvider* context_provider,
+    ResourceProvider* resource_provider) {
+  return make_scoped_ptr(
+      new GpuRasterizer(context_provider, resource_provider));
+}
+
+GpuRasterizer::GpuRasterizer(
+    ContextProvider* context_provider,
+    ResourceProvider* resource_provider)
+    : client_(NULL),
+      context_provider_(context_provider),
+      resource_provider_(resource_provider) {
+}
+
+GpuRasterizer::~GpuRasterizer() {
+}
+
+void GpuRasterizer::SetClient(GpuRasterizerClient* client) {
+  client_ = client;
+}
+
+void GpuRasterizer::PushRasterTask(
+    Tile* tile, scoped_ptr<ResourcePool::Resource> resource) {
+  raster_tasks_.push_back(new RasterTask(tile, resource.Pass()));
+}
+
+void GpuRasterizer::FlushRasterTasks(
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
+  TRACE_EVENT0("cc", "GpuRasterizer::Rasterize");
+
+  if (raster_tasks_.empty())
+    return;
+
+  blink::WebGraphicsContext3D* context = context_provider_->Context3d();
+  GrContext* gr_context = context_provider_->GrContext();
+  DCHECK(context);
+  DCHECK(gr_context);
+
+  context->makeContextCurrent();
+  gr_context->resetContext();
+  for (RasterTaskVector::iterator it = raster_tasks_.begin();
+       it != raster_tasks_.end(); ++it) {
+    RasterTask* task = *it;
+    Tile* tile = task->tile_;
+    DCHECK_NE(task->resource_->id(), 0u);
+    {
+      ResourceProvider::ScopedWriteLockGL lock(
+          resource_provider_, task->resource_->id());
+
+      DCHECK_NE(lock.texture_id(), 0u);
+      GrBackendTextureDesc desc;
+      desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+      desc.fWidth = tile->size().width();
+      desc.fHeight = tile->size().height();
+      desc.fConfig = toGrFormat(lock.format());
+      desc.fOrigin = kTopLeft_GrSurfaceOrigin;
+      desc.fTextureHandle = lock.texture_id();
+      skia::RefPtr<GrTexture> texture =
+        skia::AdoptRef(gr_context->wrapBackendTexture(desc));
+      skia::RefPtr<SkGpuDevice> device =
+        skia::AdoptRef(SkGpuDevice::Create(texture.get()));
+      CHECK(device);
+      skia::RefPtr<SkCanvas> canvas =
+        skia::AdoptRef(new SkCanvas(device.get()));
+
+      if (tile->opaque_rect().IsEmpty())

[vangelis, 2013/11/28 00:35:01]

Shouldn't we be checking here for an opaque_rect() < tile_rect ? If the tile is
partially transparent we'll still need to clear it. 

[slavi, 2013/11/28 00:47:49]

This doesn't happen currently. The opaque_rect is either tile_rect or empty:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/picture_...

+        canvas->clear(SK_ColorTRANSPARENT);
+
+      tile->picture_pile_->RasterDirect(
+          canvas.get(), tile->content_rect_, tile->contents_scale_,

[vmpstr, 2013/11/27 23:45:42]

nit: tile provides public getters for picture pile, content rect, and contents
scale. I think it's better to use those and remove the rasterizer friendship
from the tile. The friends there are only to access the managed tile state,
which this class doesn't need.

[slavi, 2013/11/28 00:47:49]

Done.

+          rendering_stats_instrumentation);
+    }
+
+    if (client_)
+      client_->OnGpuRasterTaskCompleted(tile, task->resource_.Pass(), false);
+  }
+  gr_context->flush();
+  raster_tasks_.clear();
+}
+
+}   // namespace cc