Add preliminary support for hw-accelerated tile rasterization.

cc/resources/raster_worker_pool.cc

 // 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/raster_worker_pool.h"
 
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
 #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 {
 
 namespace {
 
 // Subclass of Allocator that takes a suitably allocated pointer and uses
 // it as the pixel memory for the bitmap.
 class IdentityAllocator : public SkBitmap::Allocator {
  public:
   explicit IdentityAllocator(void* buffer) : buffer_(buffer) {}
@@ skipping 14 matching lines @@
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
 
     paint->setLCDRenderText(false);
     return true;
   }
 };
 
-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),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
-                 "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
+                 "RasterWorkerPoolTaskSW::RunAnalysisOnThread",
                  "data",
                  TracedValue::FromValue(DataAsValue().release()));
 
     DCHECK(picture_pile_.get());
     DCHECK(rendering_stats_);
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
     DCHECK(picture_clone);
 
     picture_clone->AnalyzeInRect(
         content_rect_, contents_scale_, &analysis_, rendering_stats_);
 
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);
 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   bool RunRasterOnThread(unsigned thread_index,
                          void* buffer,
                          gfx::Size size,
                          int stride) {
     TRACE_EVENT2(
-        "cc", "RasterWorkerPoolTaskImpl::RunRasterOnThread",
+        "cc", "RasterWorkerPoolTaskSW::RunRasterOnThread",
         "data",
         TracedValue::FromValue(DataAsValue().release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
 
     devtools_instrumentation::ScopedLayerTask raster_task(
         devtools_instrumentation::kRasterTask, layer_id_);
 
     DCHECK(picture_pile_.get());
     DCHECK(buffer);
@@ skipping 81 matching lines @@
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride)
       OVERRIDE {
     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 {
     scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
     res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
     res->SetInteger("source_frame_number", source_frame_number_);
     res->SetInteger("layer_id", layer_id_);
     return res.PassAs<base::Value>();
   }
@@ skipping 17 matching lines @@
   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_;
 
-  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 {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
                                 int layer_id,
                                 RenderingStatsInstrumentation* rendering_stats,
                                 const RasterWorkerPool::Task::Reply& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
         layer_id_(layer_id),
@@ skipping 128 matching lines @@
 void RasterWorkerPool::Task::Reset() {
   internal_ = NULL;
 }
 
 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());
 }
 
 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() {
   internal_ = NULL;
 }
 
 RasterWorkerPool::RasterTask::~RasterTask() {
 }
 
-// static
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     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,
+    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
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     skia::LazyPixelRef* pixel_ref,
     int layer_id,
     RenderingStatsInstrumentation* stats_instrumentation,
     const Task::Reply& reply) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(pixel_ref,
                                                 layer_id,
                                                 stats_instrumentation,
                                                 reply));
 }
 
 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) {
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
 }
 
 void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
   client_ = client;
 }
 
 void RasterWorkerPool::Shutdown() {
   raster_tasks_.clear();
   TaskGraph empty;
   SetTaskGraph(&empty);
   WorkerPool::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(
       queue->tasks_required_for_activation_);
 }
 
 bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
     internal::RasterWorkerPoolTask* task) const {
   return
       raster_tasks_required_for_activation_.find(task) !=
@@ skipping 90 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc