cc: Refactor WorkerPoolTaskClient::AcquireBufferForRaster

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 <algorithm>
 
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.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 "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/command_buffer/client/gles2_interface.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"
 
 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) {}
   virtual bool allocPixelRef(SkBitmap* dst, SkColorTable*) OVERRIDE {
@@ skipping 53 matching lines @@
         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),
-        buffer_(NULL),
-        stride_(0) {}
+        canvas_(NULL) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::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;
   }
 
-  void RunRasterOnThread(unsigned thread_index,
-                         void* buffer,
-                         const gfx::Size& size,
-                         int stride) {
+  void RunRasterOnThread(unsigned thread_index) {
     TRACE_EVENT2(
         "cc",
         "RasterWorkerPoolTaskImpl::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);
-
-    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);
+    Raster(picture_pile_->GetCloneForDrawingOnThread(thread_index));
   }
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     // TODO(alokp): For now run-on-worker-thread implies software rasterization.
     DCHECK(!use_gpu_rasterization());
     RunAnalysisOnThread(thread_index);
-    if (buffer_ && !analysis_.is_solid_color)
-      RunRasterOnThread(thread_index, buffer_, resource()->size(), stride_);
+    if (canvas_ && !analysis_.is_solid_color)
+      RunRasterOnThread(thread_index);
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
-    if (use_gpu_rasterization())
-      return;
-    DCHECK(!buffer_);
-    buffer_ = client->AcquireBufferForRaster(this, &stride_);
+    DCHECK(!canvas_);
+    canvas_ = client->AcquireCanvasForRaster(this);
   }
   virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
       OVERRIDE {
-    if (use_gpu_rasterization())
-      return;
-    buffer_ = NULL;
+    canvas_ = NULL;
     client->OnRasterCompleted(this, analysis_);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
-    DCHECK(!buffer_);
+    DCHECK(!canvas_);
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual void RunOnOriginThread(ResourceProvider* resource_provider,
                                  ContextProvider* context_provider) OVERRIDE {
     // TODO(alokp): Use a trace macro to push/pop markers.
     // Using push/pop functions directly incurs cost to evaluate function
     // arguments even when tracing is disabled.
     context_provider->ContextGL()->PushGroupMarkerEXT(
         0,
         base::StringPrintf(
             "Raster-%d-%d-%p", source_frame_number_, layer_id_, tile_id_)
             .c_str());
     // 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());
+    Raster(picture_pile_);
     context_provider->ContextGL()->PopGroupMarkerEXT();
   }
 
  protected:
-  virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!buffer_); }
+  virtual ~RasterWorkerPoolTaskImpl() { DCHECK(!canvas_); }
 
  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) {
+  void Raster(PicturePileImpl* picture_pile) {
     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)
     RenderingStatsInstrumentation* stats =
         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
-    picture_pile->RasterToBitmap(canvas, content_rect_, contents_scale_, stats);
+    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);
     }
   }
 
-  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);
-      // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
-      // bitmap data. This check will be removed once crbug.com/293728 is fixed.
-      CHECK_EQ(0u, bitmap_dest.rowBytes() % 4);
-    }
-  }
-
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<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_;
-  void* buffer_;
-  int stride_;
+  SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(SkPixelRef* pixel_ref,
                                 int layer_id,
                                 RenderingStatsInstrumentation* rendering_stats,
                                 const RasterWorkerPool::Task::Reply& reply)
@@ skipping 469 matching lines @@
     if (decode_it == graph->nodes.end())
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(internal::TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 }  // namespace cc