cc: Adding support for RGBA_4444 tile textures

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/benchmark_instrumentation.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/picture_pile_impl.h"
+#include "cc/resources/resource_provider.h"
 #include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/paint_simplifier.h"
+#include "third_party/skia/include/core/SkBitmap.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 {
+    dst->setPixels(buffer_);
+    return true;
+  }
+ private:
+  void* buffer_;
+};
+
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
   // SkDrawFilter interface.
   virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) OVERRIDE {
     if (type != SkDrawFilter::kText_Type)
       return true;
@@ skipping 22 matching lines @@
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
         is_tile_in_pending_tree_now_bin_(is_tile_in_pending_tree_now_bin),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
-        reply_(reply) {}
+        reply_(reply),
+        texture_format_(resource->format()) {}
 
   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);
 
     base::TimeTicks start_time = rendering_stats_->StartRecording();
     picture_clone->AnalyzeInRect(content_rect_, contents_scale_, &analysis_);
     base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
 
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);
     rendering_stats_->AddAnalysisResult(duration, analysis_.is_solid_color);
 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
-  bool RunRasterOnThread(SkBaseDevice* device, unsigned thread_index) {
+  bool RunRasterOnThread(unsigned thread_index,
+                         void* buffer,
+                         gfx::Size size,
+                         int stride) {
     TRACE_EVENT2(
         benchmark_instrumentation::kCategory,
         benchmark_instrumentation::kRunRasterOnThread,
         benchmark_instrumentation::kData,
         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(device);
+    DCHECK(buffer);
 
     if (analysis_.is_solid_color)
       return false;
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
-    SkCanvas canvas(device);
+    SkBitmap bitmap_32;

[reveman, 2013/09/13 14:32:49]

can we drop the _32 suffix here?

[kaanb, 2013/09/13 19:57:39]

Done.

+    bitmap_32.setConfig(SkBitmap::kARGB_8888_Config,
+                        size.width(),
+                        size.height(),
+                        stride);

[reveman, 2013/09/13 14:32:49]

stride is not going to be correct here unless format is RGBA_8888 or BGRA_8888.
you should probably move this into the switch statement and not set stride in
the case of RGBA_4444.

[kaanb, 2013/09/13 19:57:39]

Done.

+    switch (texture_format_) {
+      case ResourceProvider::RGBA_4444:
+        bitmap_32.allocPixels();
+        break;
+      case ResourceProvider::RGBA_8888:
+      case ResourceProvider::BGRA_8888:
+      case ResourceProvider::LUMINANCE_8:

[reveman, 2013/09/13 14:32:49]

Using SkBitmap::kARGB_8888_Config for LUMINANCE_8 doesn't look right. I'd rather
we make it explicit that this format is not supported.

[kaanb, 2013/09/13 19:57:39]

Done.

+        bitmap_32.setPixels(buffer);
+        break;
+    }
 
+    SkBitmapDevice device_32(bitmap_32);

[reveman, 2013/09/13 14:32:49]

drop _32?

[kaanb, 2013/09/13 19:57:39]

Done.

+    SkCanvas canvas(&device_32);
     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;
@@ skipping 17 matching lines @@
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           raster_stats.total_rasterize_time.InMicroseconds(),
           0,
           100000,
           100);
     } else {
       picture_clone->RasterToBitmap(
           &canvas, content_rect_, contents_scale_, NULL);
     }
+
+    if (texture_format_ == ResourceProvider::RGBA_4444) {
+      TRACE_EVENT0("cc",
+                   "RasterWorkerPoolTaskImpl::RunRasterOnThread::Downsample");

[reveman, 2013/09/13 14:32:49]

If this is worth a trace event then I prefer if you moved it to a helper
function.

[kaanb, 2013/09/13 19:57:39]

Done.

+      SkBitmap bitmap_16;
+      IdentityAllocator allocator(buffer);
+      bitmap_32.copyTo(&bitmap_16, SkBitmap::kARGB_4444_Config, &allocator);
+    }

[reveman, 2013/09/13 14:32:49]

This is currently hardcoded to only support RGBA_4444. I think it needs to be
generalized a bit. Maybe add a SkBitmapConfigFromFormat helper function that
determines the config to use with copyTo and you can also use that to determine
if the copy is needed. ie. bitmap.getConfig() !=
SkBitmapConfigFromFormat(format).

[kaanb, 2013/09/13 19:57:39]

Done.

+
     return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
-  virtual bool RunOnWorkerThread(SkBaseDevice* device, unsigned thread_index)
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride)
       OVERRIDE {
     RunAnalysisOnThread(thread_index);
-    return RunRasterOnThread(device, 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 {
@@ skipping 12 matching lines @@
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
   bool is_tile_in_pending_tree_now_bin_;
   TileResolution tile_resolution_;
   int layer_id_;
   const void* tile_id_;
   int source_frame_number_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
+  ResourceProvider::Format texture_format_;

[reveman, 2013/09/13 14:32:49]

I don't think you need this. You can get the format from resource()->format().

[kaanb, 2013/09/13 19:57:39]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
                                 int layer_id,
                                 RenderingStatsInstrumentation* rendering_stats,
                                 const RasterWorkerPool::Task::Reply& reply)
@@ skipping 332 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc