Add preliminary support for hw-accelerated tile rasterization.

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 06fd18e62e0ec2bdc9d440ee0ae6eb925c867ef4..cbf53f08e3d6467060a5d4410a9993110446b009 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -13,6 +13,9 @@
 #include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/SkGpuDevice.h"
+#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 
 namespace cc {
 
@@ -58,10 +61,13 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
                            int layer_id,
                            const void* tile_id,
                            int source_frame_number,
+                           bool use_gpu_rasterization,
                            RenderingStatsInstrumentation* rendering_stats,
                            const RasterWorkerPool::RasterTask::Reply& reply,
                            TaskVector* dependencies)
-      : internal::RasterWorkerPoolTask(resource, dependencies),
+      : internal::RasterWorkerPoolTask(resource,
+                                       dependencies,
+                                       use_gpu_rasterization),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
@@ -118,9 +124,6 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     if (analysis_.is_solid_color)
       return false;
 
-    PicturePileImpl* picture_clone =
-        picture_pile_->GetCloneForDrawingOnThread(thread_index);
-
     SkBitmap bitmap;
     switch (resource()->format()) {
       case RGBA_4444:
@@ -148,6 +151,13 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
 
     SkBitmapDevice device(bitmap);
     SkCanvas canvas(&device);
+    Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index), &canvas);
+    ChangeBitmapConfigIfNeeded(bitmap, buffer);
+
+    return true;
+  }
+
+  void Raster(PicturePileImpl* picture_pile, SkCanvas* canvas) {

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

can this be private?

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

Done.

     skia::RefPtr<SkDrawFilter> draw_filter;
     switch (raster_mode_) {
       case LOW_QUALITY_RASTER_MODE:
@@ -162,8 +172,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
       default:
         NOTREACHED();
     }
-
-    canvas.setDrawFilter(draw_filter.get());
+    canvas->setDrawFilter(draw_filter.get());
 
     base::TimeDelta prev_rasterize_time =
         rendering_stats_->impl_thread_rendering_stats().rasterize_time;
@@ -172,13 +181,9 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     // lowres tiles are not required for activation and therefore
     // introduce noise in the measurement (sometimes they get rasterized
     // before we draw and sometimes they aren't)
-    if (tile_resolution_ == HIGH_RESOLUTION) {
-      picture_clone->RasterToBitmap(
-          &canvas, content_rect_, contents_scale_, rendering_stats_);
-    } else {
-      picture_clone->RasterToBitmap(
-          &canvas, content_rect_, contents_scale_, NULL);
-    }
+    RenderingStatsInstrumentation* stats = tile_resolution_ == HIGH_RESOLUTION ?
+        rendering_stats_ : NULL;
+    picture_pile->RasterToBitmap(canvas, content_rect_, contents_scale_, stats);
 
     if (rendering_stats_->record_rendering_stats()) {
       base::TimeDelta current_rasterize_time =
@@ -190,21 +195,43 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
           100000,
           100);
     }
-
-    ChangeBitmapConfigIfNeeded(bitmap, buffer);
-
-    return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
-                                 int stride)
-      OVERRIDE {
+                                 int stride) OVERRIDE {
+    DCHECK(!use_gpu_rasterization());
     RunAnalysisOnThread(thread_index);
     return RunRasterOnThread(thread_index, buffer, size, stride);
   }
+
+  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
+                                 ContextProvider* context_provider) OVERRIDE {
+    DCHECK(use_gpu_rasterization());
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider,
+                                             resource()->id());
+    DCHECK_NE(lock.texture_id(), 0u);
+
+    GrBackendTextureDesc desc;
+    desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+    desc.fWidth = content_rect_.width();
+    desc.fHeight = content_rect_.height();
+    desc.fConfig = ToGrFormat(resource()->format());
+    desc.fOrigin = kTopLeft_GrSurfaceOrigin;
+    desc.fTextureHandle = lock.texture_id();
+
+    GrContext* gr_context = context_provider->GrContext();
+    skia::RefPtr<GrTexture> texture =
+        skia::AdoptRef(gr_context->wrapBackendTexture(desc));
+    skia::RefPtr<SkGpuDevice> device =
+        skia::AdoptRef(SkGpuDevice::Create(texture.get()));
+    skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(new SkCanvas(device.get()));
+
+    Raster(picture_pile_, canvas.get());
+  }
+
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(analysis_, !HasFinishedRunning() || WasCanceled());
   }
@@ -222,6 +249,17 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     return res.PassAs<base::Value>();
   }
 
+  static 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;
+    }
+    DCHECK(false) << "Unsupported resource format.";
+    return kSkia8888_GrPixelConfig;
+  }
+
   void ChangeBitmapConfigIfNeeded(const SkBitmap& bitmap,
                                   void* buffer) {
     TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::ChangeBitmapConfigIfNeeded");
@@ -325,12 +363,14 @@ const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 namespace internal {
 
-RasterWorkerPoolTask::RasterWorkerPoolTask(
-    const Resource* resource, TaskVector* dependencies)
+RasterWorkerPoolTask::RasterWorkerPoolTask(const Resource* resource,
+                                           TaskVector* dependencies,
+                                           bool use_gpu_rasterization)
     : did_run_(false),
       did_complete_(false),
       was_canceled_(false),
-      resource_(resource) {
+      resource_(resource),
+      use_gpu_rasterization_(use_gpu_rasterization) {
   dependencies_.swap(*dependencies);
 }
 
@@ -431,6 +471,7 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     int layer_id,
     const void* tile_id,
     int source_frame_number,
+    bool use_gpu_rasterization,
     RenderingStatsInstrumentation* rendering_stats,
     const RasterTask::Reply& reply,
     Task::Set* dependencies) {
@@ -444,6 +485,7 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
                                    layer_id,
                                    tile_id,
                                    source_frame_number,
+                                   use_gpu_rasterization,
                                    rendering_stats,
                                    reply,
                                    &dependencies->tasks_));
@@ -462,10 +504,12 @@ RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
 }
 
 RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
+                                   ContextProvider* context_provider,
                                    size_t num_threads)
     : WorkerPool(num_threads, kWorkerThreadNamePrefix),
       client_(NULL),
       resource_provider_(resource_provider),
+      context_provider_(context_provider),
       weak_ptr_factory_(this) {
 }
 
@@ -497,6 +541,24 @@ bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
       raster_tasks_required_for_activation_.end();
 }
 
+void RasterWorkerPool::RunGpuRasterizationTasks(RasterTaskVector& tasks) {
+  if (tasks.empty()) return;

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

nit: move "return" to next line.

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

Done.

+
+  blink::WebGraphicsContext3D* context = context_provider_->Context3d();
+  context->makeContextCurrent();
+
+  GrContext* gr_context = context_provider_->GrContext();
+  gr_context->resetContext();
+
+  for (RasterTaskVector::iterator it = tasks.begin(); it != tasks.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = (*it).get();
+    DCHECK(task->use_gpu_rasterization());
+    task->RunOnOriginThread(resource_provider_, context_provider_);

[vmpstr, 2013/12/17 22:52:45]

This kind of looks weird to me... We have a task->RunOnOriginThread (a generic
name) which takes specific objects, because we of course know what we need to
give for gpu rasterization :) 

It's not so much a comment on this patch, since I can see that RunOnWorkerThread
also takes some items that are not exactly generic.

In any case, there seems to be a bit of struggle between using generic types
that are opaque and will complete their work when needed (ie tasks / task vector
/ raster task / etc), and doing things like
DCHECK(task->use_gpu_rasterization()) and RunGpuRasterizationTasks where it's
not so much opaque anymore as to what is happening.


Do you think it might be better if we had a flag "should run on main thread" vs
"should run on worker thread" (i thought i saw something like this in here
already?), and keep the rest of the details opaque? Maybe add a new type of task
that is kind of like RasterTask except implemented with ganesh?

I'll admit that this code was already a bit too involved for me to really
understand the nuances of interacting between task vector/queues and RWP and
PBRWP and WP, so I'm reluctantly OK with this approach if that's what people
have decided (ie, this comment is mostly a structural comment, not
implementation details comment).

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

I admit - it is awkward. I also do not like must-run-on-origin-thread flag. It
does not say anything about GPU rasterization. I think longer term,
RasterWorkerPoolTask should not worry about origin/worker threads. It would just
Run and Complete on whatever thread they are called. The wrapper classes would
setup the thread and canvas.

I believe this kind of refactoring can be done in subsequent patches. This patch
at least pushes this complexity from TileManager to RasterWorkerPool and lets us
experiment with gpu rasterization.

+  }
+
+  gr_context->flush();
+}
+
 scoped_refptr<internal::WorkerPoolTask>
     RasterWorkerPool::CreateRasterFinishedTask() {
   return make_scoped_refptr(