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/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPixelRef.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 25 matching lines @@
  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,
+                           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),
         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) {}
@@ skipping 36 matching lines @@
 
     devtools_instrumentation::ScopedLayerTask raster_task(
         devtools_instrumentation::kRasterTask, layer_id_);
 
     DCHECK(picture_pile_.get());
     DCHECK(buffer);
 
     if (analysis_.is_solid_color)
       return false;
 
-    PicturePileImpl* picture_clone =
-        picture_pile_->GetCloneForDrawingOnThread(thread_index);
-
     SkBitmap bitmap;
     switch (resource()->format()) {
       case RGBA_4444:
         // Use the default stride if we will eventually convert this
         // bitmap to 4444.
         bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                          size.width(),
                          size.height());
         bitmap.allocPixels();
         break;
       case RGBA_8888:
       case BGRA_8888:
         bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                          size.width(),
                          size.height(),
                          stride);
         bitmap.setPixels(buffer);
         break;
       case LUMINANCE_8:
       case RGB_565:
       case ETC1:
         NOTREACHED();
         break;
     }
 
     SkBitmapDevice device(bitmap);
     SkCanvas canvas(&device);
+    Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index), &canvas);
+    ChangeBitmapConfigIfNeeded(bitmap, buffer);
+
+    return true;
+  }
+
+  // Overridden from internal::RasterWorkerPoolTask:
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride) OVERRIDE {
+    // TODO(alokp): For now run-on-worker-thread implies software rasterization.
+    DCHECK(!use_gpu_rasterization());
+    RunAnalysisOnThread(thread_index);
+    return RunRasterOnThread(thread_index, buffer, size, stride);
+  }
+
+  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
+                                 ContextProvider* context_provider) OVERRIDE {
+    // TODO(alokp): For now run-on-origin-thread implies gpu rasterization.
+    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());
+  }
+
+ protected:
+  virtual ~RasterWorkerPoolTaskImpl() {}
+
+ 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>();
+  }
+
+  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 Raster(PicturePileImpl* picture_pile, SkCanvas* canvas) {
     skia::RefPtr<SkDrawFilter> draw_filter;
     switch (raster_mode_) {
       case LOW_QUALITY_RASTER_MODE:
         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
         break;
       case HIGH_QUALITY_NO_LCD_RASTER_MODE:
         draw_filter = skia::AdoptRef(new DisableLCDTextFilter);
         break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
       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;
 
     // Only record rasterization time for highres tiles, because
     // 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 =
           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           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 {
-    RunAnalysisOnThread(thread_index);
-    return RunRasterOnThread(thread_index, buffer, size, stride);
-  }
-  virtual void CompleteOnOriginThread() OVERRIDE {
-    reply_.Run(analysis_, !HasFinishedRunning() || WasCanceled());
-  }
-
- protected:
-  virtual ~RasterWorkerPoolTaskImpl() {}
-
- 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>();
   }
 
   void ChangeBitmapConfigIfNeeded(const SkBitmap& bitmap,
                                   void* buffer) {
     TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::ChangeBitmapConfigIfNeeded");
     SkBitmap::Config config = SkBitmapConfig(resource()->format());
     if (bitmap.getConfig() != config) {
       SkBitmap bitmap_dest;
       IdentityAllocator allocator(buffer);
       bitmap.copyTo(&bitmap_dest, config, &allocator);
@@ skipping 87 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
 
 const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
 
 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);
 }
 
 RasterWorkerPoolTask::~RasterWorkerPoolTask() {
 }
 
 void RasterWorkerPoolTask::DidRun(bool was_canceled) {
   DCHECK(!did_run_);
   did_run_ = true;
   was_canceled_ = was_canceled;
@@ skipping 80 matching lines @@
 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,
+                                   use_gpu_rasterization,
                                    rendering_stats,
                                    reply,
                                    &dependencies->tasks_));
 }
 
 // static
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     SkPixelRef* 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::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "RasterWorkerPool::CheckForCompletedTasks");
+
+  // Check for completed worker-thread tasks.
+  CheckForCompletedWorkerTasks();
+
+  // Complete gpu rasterization tasks.
+  while (!completed_gpu_raster_tasks_.empty()) {
+    internal::RasterWorkerPoolTask* task =
+        completed_gpu_raster_tasks_.front().get();
+    task->WillComplete();
+    task->CompleteOnOriginThread();
+    task->DidComplete();
+
+    completed_gpu_raster_tasks_.pop_front();
+  }
+}
+
 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) !=
       raster_tasks_required_for_activation_.end();
 }
 
+void RasterWorkerPool::RunGpuRasterTasks(const RasterTaskVector& tasks) {
+  if (tasks.empty())
+    return;
+
+  blink::WebGraphicsContext3D* context = context_provider_->Context3d();
+  if (!context->makeContextCurrent())
+    return;
+
+  GrContext* gr_context = context_provider_->GrContext();
+  // TODO(alokp): Implement TestContextProvider::GrContext().
+  if (gr_context) gr_context->resetContext();
+
+  for (RasterTaskVector::const_iterator it = tasks.begin();
+       it != tasks.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = it->get();
+    DCHECK(task->use_gpu_rasterization());
+
+    task->RunOnOriginThread(resource_provider_, context_provider_);
+    task->DidRun(false);
+    completed_gpu_raster_tasks_.push_back(task);
+  }
+
+  // TODO(alokp): Implement TestContextProvider::GrContext().
+  if (gr_context) gr_context->flush();
+}
+
 scoped_refptr<internal::WorkerPoolTask>
     RasterWorkerPool::CreateRasterFinishedTask() {
   return make_scoped_refptr(
       new RasterFinishedWorkerPoolTaskImpl(
           base::Bind(&RasterWorkerPool::OnRasterFinished,
                      weak_ptr_factory_.GetWeakPtr())));
 }
 
 scoped_refptr<internal::WorkerPoolTask>
     RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask() {
@@ skipping 77 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc