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..7aadd188acef0c36e593404bf01d3bf087d0e43c 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 {
 
@@ -47,20 +50,20 @@ class DisableLCDTextFilter : public SkDrawFilter {
   }
 };
 
-class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
+class RasterWorkerPoolTaskSW : public internal::RasterWorkerPoolTask {
  public:
-  RasterWorkerPoolTaskImpl(const Resource* resource,
-                           PicturePileImpl* picture_pile,
-                           gfx::Rect content_rect,
-                           float contents_scale,
-                           RasterMode raster_mode,
-                           TileResolution tile_resolution,
-                           int layer_id,
-                           const void* tile_id,
-                           int source_frame_number,
-                           RenderingStatsInstrumentation* rendering_stats,
-                           const RasterWorkerPool::RasterTask::Reply& reply,
-                           TaskVector* dependencies)
+  RasterWorkerPoolTaskSW(const Resource* resource,
+                         PicturePileImpl* picture_pile,
+                         gfx::Rect content_rect,
+                         float contents_scale,
+                         RasterMode raster_mode,
+                         TileResolution tile_resolution,
+                         int layer_id,
+                         const void* tile_id,
+                         int source_frame_number,
+                         RenderingStatsInstrumentation* rendering_stats,
+                         const RasterWorkerPool::RasterTask::Reply& reply,
+                         TaskVector* dependencies)
       : internal::RasterWorkerPoolTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
@@ -75,7 +78,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
-                 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
+                 "RasterWorkerPoolTaskSW::RunAnalysisOnThread",
                  "data",
                  TracedValue::FromValue(DataAsValue().release()));
 
@@ -103,7 +106,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
                          gfx::Size size,
                          int stride) {
     TRACE_EVENT2(
-        "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
+        "cc", "RasterWorkerPoolTaskSW::RunRasterOnThread",
         "data",
         TracedValue::FromValue(DataAsValue().release()),
         "raster_mode",
@@ -205,12 +208,15 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     RunAnalysisOnThread(thread_index);
     return RunRasterOnThread(thread_index, buffer, size, stride);
   }
+  virtual void RunOnOriginThread() OVERRIDE {
+    NOTREACHED();
+  }
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(analysis_, !HasFinishedRunning() || WasCanceled());
   }
 
  protected:
-  virtual ~RasterWorkerPoolTaskImpl() {}
+  virtual ~RasterWorkerPoolTaskSW() {}
 
  private:
   scoped_ptr<base::Value> DataAsValue() const {
@@ -248,7 +254,91 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
-  DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskSW);
+};
+
+class RasterWorkerPoolTaskGPU : public internal::RasterWorkerPoolTask {

[reveman, 2013/12/17 00:28:48]

Could we use RasterWorkerPoolTaskImpl for this instead? And just add a
gpu_rasterization flag and appropriate DCHECKs to RunOnOriginThread() and
RunOnOriginThread()?

[alokp, 2013/12/17 22:12:15]

Done.

+ public:
+  RasterWorkerPoolTaskGPU(const Resource* resource,
+                          PicturePileImpl* picture_pile,
+                          gfx::Rect content_rect,
+                          float contents_scale,
+                          ResourceProvider* resource_provider,
+                          ContextProvider* context_provider,
+                          RenderingStatsInstrumentation* rendering_stats,
+                          const RasterWorkerPool::RasterTask::Reply& reply,
+                          TaskVector* dependencies)
+      : internal::RasterWorkerPoolTask(resource, dependencies),
+        picture_pile_(picture_pile),
+        content_rect_(content_rect),
+        contents_scale_(contents_scale),
+        resource_provider_(resource_provider),
+        context_provider_(context_provider),
+        rendering_stats_(rendering_stats),
+        reply_(reply) {}
+
+  // Overridden from internal::RasterWorkerPoolTask:
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride) OVERRIDE {
+    NOTREACHED();
+    return false;
+  }
+  virtual void RunOnOriginThread() OVERRIDE {
+    DCHECK_NE(resource()->id(), 0u);
+    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());

[reveman, 2013/12/17 00:28:48]

How are GrPixelConfig formats used by Ganesh? Some of our shaders depend on
components having to be swizzled if
"!PlatformColor::SameComponentOrder(resource_->format())" is true. Is that also
true for when we raster with Ganesh?

[alokp, 2013/12/17 22:12:15]

Swizzling is never required when rasterizing with Ganesh. I will make sure that
this assertion is true.

+    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()));
+
+    canvas->clear(SK_ColorTRANSPARENT);
+    picture_pile_->RasterDirect(canvas.get(),
+                                content_rect_,
+                                contents_scale_,
+                                rendering_stats_);
+    gr_context->flush();

[reveman, 2013/12/17 00:28:48]

as you have a flush in CompleteOriginThreadTasks, should we avoid the flush
here?

[alokp, 2013/12/17 22:12:15]

Done.

+  }
+  virtual void CompleteOnOriginThread() OVERRIDE {
+    reply_.Run(PicturePileImpl::Analysis(), false);
+  }
+
+ protected:
+  virtual ~RasterWorkerPoolTaskGPU() {}
+
+  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;
+  }
+
+ private:
+  scoped_refptr<PicturePileImpl> picture_pile_;
+  gfx::Rect content_rect_;
+  float contents_scale_;
+  ResourceProvider* resource_provider_;
+  ContextProvider* context_provider_;
+  RenderingStatsInstrumentation* rendering_stats_;
+  const RasterWorkerPool::RasterTask::Reply reply_;
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
@@ -397,9 +487,15 @@ RasterWorkerPool::RasterTask::Queue::Queue() {
 RasterWorkerPool::RasterTask::Queue::~Queue() {
 }
 
-void RasterWorkerPool::RasterTask::Queue::Append(
-    const RasterTask& task, bool required_for_activation) {
+void RasterWorkerPool::RasterTask::Queue::Append(const RasterTask& task,
+                                                 bool required_for_activation) {
   DCHECK(!task.is_null());
+
+  if (task.must_run_on_origin_thread_) {
+    origin_thread_tasks_.push_back(task.internal_);
+    return;
+  }
+
   tasks_.push_back(task.internal_);
   if (required_for_activation)
     tasks_required_for_activation_.insert(task.internal_.get());
@@ -409,8 +505,10 @@ RasterWorkerPool::RasterTask::RasterTask() {
 }
 
 RasterWorkerPool::RasterTask::RasterTask(
-    internal::RasterWorkerPoolTask* internal)
-    : internal_(internal) {
+    internal::RasterWorkerPoolTask* internal,
+    bool must_run_on_origin_thread)
+    : internal_(internal),
+      must_run_on_origin_thread_(must_run_on_origin_thread) {
 }
 
 void RasterWorkerPool::RasterTask::Reset() {
@@ -420,7 +518,6 @@ void RasterWorkerPool::RasterTask::Reset() {
 RasterWorkerPool::RasterTask::~RasterTask() {
 }
 
-// static
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     const Resource* resource,
     PicturePileImpl* picture_pile,
@@ -431,22 +528,36 @@ 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) {
-  return RasterTask(
-      new RasterWorkerPoolTaskImpl(resource,
-                                   picture_pile,
-                                   content_rect,
-                                   contents_scale,
-                                   raster_mode,
-                                   tile_resolution,
-                                   layer_id,
-                                   tile_id,
-                                   source_frame_number,
-                                   rendering_stats,
-                                   reply,
-                                   &dependencies->tasks_));
+  internal::RasterWorkerPoolTask* impl = NULL;
+  if (use_gpu_rasterization) {
+    impl = new RasterWorkerPoolTaskGPU(resource,
+                                       picture_pile,
+                                       content_rect,
+                                       contents_scale,
+                                       resource_provider_,
+                                       context_provider_,
+                                       rendering_stats,
+                                       reply,
+                                       &dependencies->tasks_);
+  } else {
+    impl = new RasterWorkerPoolTaskSW(resource,
+                                      picture_pile,
+                                      content_rect,
+                                      contents_scale,
+                                      raster_mode,
+                                      tile_resolution,
+                                      layer_id,
+                                      tile_id,
+                                      source_frame_number,
+                                      rendering_stats,
+                                      reply,
+                                      &dependencies->tasks_);
+  }
+  return RasterTask(impl, use_gpu_rasterization);

[vmpstr, 2013/12/17 21:04:37]

This might be echoing some of David's comments, but why do we need to pass
use_gpu_rasterization here if impl is already set to be the correct thing?

[alokp, 2013/12/17 22:12:15]

Done.

 }
 
 // static
@@ -462,10 +573,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) {
 }
 
@@ -484,6 +597,26 @@ void RasterWorkerPool::Shutdown() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
+void RasterWorkerPool::CompleteOriginThreadTasks(RasterTask::Queue* queue) {

[reveman, 2013/12/17 00:28:48]

I think this needs to be RunTasksOnOriginThread (Or
RunGpuRasterizationTasksOnOriginThread). See my comment below.

[alokp, 2013/12/17 22:12:15]

Done.

+  if (queue->origin_thread_tasks_.empty())
+    return;
+
+  blink::WebGraphicsContext3D* context = context_provider_->Context3d();
+  GrContext* gr_context = context_provider_->GrContext();
+  context->makeContextCurrent();
+  gr_context->resetContext();
+
+  for (RasterTaskVector::iterator it = queue->origin_thread_tasks_.begin();
+      it != queue->origin_thread_tasks_.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = (*it).get();
+    task->RunOnOriginThread();
+    task->CompleteOnOriginThread();

[reveman, 2013/12/17 00:28:48]

Task completion needs to be delayed until ::CheckForCompletedTasks() is called.
The RasterWorkerPool implementation will need to take care of this.

[alokp, 2013/12/17 22:12:15]

AFAICT ImageRasterWorkerPool never calls CheckForCompletedTasks(). Also there is
no RasterWorkerPool::CheckForCompletedTasks(), it is in fact
WorkerPool::CheckForCompletedTasks(), which only evaluates tasks in the
task-graph. Since we do not put gpu-raster tasks in the graph, it is not
directly applicable here.

I have implemented it in a slightly different way, please check the latest patch
if it seems reasonable.

+  }
+
+  gr_context->flush();
+  queue->origin_thread_tasks_.clear();
+}
+
 void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
   raster_tasks_.swap(queue->tasks_);
   raster_tasks_required_for_activation_.swap(