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"
@@ skipping 30 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,
-                           TaskVector* dependencies)
+                           TaskVector* dependencies,
+                           bool use_16bit_tiles)
       : internal::RasterWorkerPoolTask(resource, dependencies),
         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),
+        use_16bit_tiles_(use_16bit_tiles) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
                  "data",
                  TracedValue::FromValue(DataAsValue().release()));
 
     DCHECK(picture_pile_.get());
     DCHECK(rendering_stats_);
 
@@ skipping 30 matching lines @@
     DCHECK(picture_pile_.get());
     DCHECK(device);
 
     if (analysis_.is_solid_color)
       return false;
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
     SkCanvas canvas(device);
-
     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 (use_16bit_tiles_) {
+      const SkBitmap& bitmap_32 = device->accessBitmap(true);
+      SkBitmap bitmap_16;
+      bitmap_32.copyTo(&bitmap_16, SkBitmap::kARGB_4444_Config);
+      canvas.drawBitmap(bitmap_16, 0, 0);

[Sami, 2013/08/08 10:11:01]

|canvas| is still a 32-bit bitmap so this is really just going from 32 => 16 =>
32 bits, i.e., throwing away precision :) I think we need to add a way to make
PixelBufferWorkerPoolTaskImpl give us a 16-bit device (which isn't supported by
Skia AFAIK).

[kaanb, 2013/08/08 17:25:05]

Let me check with Skia folks if they'd be willing to make a shortcut for us
here.

[bsalomon, 2013/08/08 18:40:15]

Hi, What's the intent here? Are you trying to go from a 16bit sw bitmap to a
16bit texture? bitmap_16 is a sw bitmap, is bitmap_32 a texture backed bitmap?

Also, I'm not sure how much it matters but it looks like accessBitmap() could
take false for the "changePixels" param since you are just reading from it.

+    }
+
     return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(SkDevice* device, unsigned thread_index)
       OVERRIDE {
     RunAnalysisOnThread(thread_index);
     return RunRasterOnThread(device, thread_index);
   }
   virtual void CompleteOnOriginThread() OVERRIDE {
@@ skipping 20 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_;
+  bool use_16bit_tiles_;
 
   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 170 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 RasterTask::Reply& reply,
-    Task::Set* dependencies) {
+    Task::Set* dependencies,
+    bool use_16bit_tiles) {
   return RasterTask(
       new RasterWorkerPoolTaskImpl(resource,
                                    picture_pile,
                                    content_rect,
                                    contents_scale,
                                    raster_mode,
                                    is_tile_in_pending_tree_now_bin,
                                    tile_resolution,
                                    layer_id,
                                    tile_id,
                                    source_frame_number,
                                    rendering_stats,
                                    reply,
-                                   &dependencies->tasks_));
+                                   &dependencies->tasks_,
+                                   use_16bit_tiles));
 }
 
 // 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,
@@ skipping 127 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc