Allow one-copy task tile worker pool to use compressed textures.

cc/raster/tile_task_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/raster/tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/playback/raster_source.h"
+#include "cc/raster/texture_compressor.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDrawFilter.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace cc {
 namespace {
 
 class TaskSetFinishedTaskImpl : public TileTask {
  public:
@@ skipping 113 matching lines @@
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
   switch (format) {
     case RGBA_4444:
     case RGBA_8888:
     case BGRA_8888:
+    case ETC1:
       return true;
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
-    case ETC1:
     case RED_8:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 class SkipImageFilter : public SkDrawFilter {
  public:
   bool filter(SkPaint* paint, Type type) override {
@@ skipping 15 matching lines @@
                                           const gfx::Rect& canvas_playback_rect,
                                           float scale,
                                           bool include_images) {
   TRACE_EVENT0("cc", "TileTaskWorkerPool::PlaybackToMemory");
 
   DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
 
   // Uses kPremul_SkAlphaType since the result is not known to be opaque.
   SkImageInfo info =
       SkImageInfo::MakeN32(size.width(), size.height(), kPremul_SkAlphaType);
-  SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
-  bool needs_copy = buffer_color_type != info.colorType();
+  bool needs_conversion =

[reveman, 2015/09/30 09:55:15]

Can we instead include the non-conversion case in the switch statement?
::PlaybackToMemory becomes a large switch statement based on format and we can
remove IsSupportedPlaybackToMemoryFormat as that will be covered by this switch
statement. I think that would also remove the need for a
SkColorTypeToResourceFormat function..

[christiank, 2015/11/26 15:35:35]

I can't think of an obvious way to do this. I still think we need some way of
checking if conversion is needed inside the switch cases to support conversion
between RGBA and BGRA depending on the platform format.

I'll give this another shot after rebasing to see if it makes things easier.

[reveman, 2015/11/27 16:46:49]

fyi, I don't we ever convert from rgba to bgra in software. we prefer to flip
the channels in the shader when necessary. 

+      SkColorTypeToResourceFormat(info.colorType()) != format;
 
   // Use unknown pixel geometry to disable LCD text.
   SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
   if (raster_source->CanUseLCDText()) {
     // LegacyFontHost will get LCD text and skia figures out what type to use.
     surface_props = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
   }
 
   if (!stride)
     stride = info.minRowBytes();
   DCHECK_GT(stride, 0u);
 
   skia::RefPtr<SkDrawFilter> image_filter;
   if (!include_images)
     image_filter = skia::AdoptRef(new SkipImageFilter);
 
-  if (!needs_copy) {
+  if (!needs_conversion) {
     skia::RefPtr<SkSurface> surface = skia::AdoptRef(
         SkSurface::NewRasterDirect(info, memory, stride, &surface_props));
     skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
     canvas->setDrawFilter(image_filter.get());
     raster_source->PlaybackToCanvas(canvas.get(), canvas_bitmap_rect,
                                     canvas_playback_rect, scale);
     return;
   }
 
   skia::RefPtr<SkSurface> surface =
       skia::AdoptRef(SkSurface::NewRaster(info, &surface_props));
   skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
   canvas->setDrawFilter(image_filter.get());
   // TODO(reveman): Improve partial raster support by reducing the size of
   // playback rect passed to PlaybackToCanvas. crbug.com/519070
   raster_source->PlaybackToCanvas(canvas.get(), canvas_bitmap_rect,
                                   canvas_bitmap_rect, scale);
 
   {
     TRACE_EVENT0("cc", "TileTaskWorkerPool::PlaybackToMemory::ConvertPixels");
 
-    SkImageInfo dst_info =
-        SkImageInfo::Make(info.width(), info.height(), buffer_color_type,
-                          info.alphaType(), info.profileType());
-    // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
-    // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
-    // is fixed.
-    const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
-    DCHECK_EQ(0u, dst_row_bytes % 4);
-    bool success = canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
-    DCHECK_EQ(true, success);
+    scoped_ptr<TextureCompressor> texture_compressor;

[reveman, 2015/09/30 09:55:15]

nit: move to case where it's used

[christiank, 2015/11/26 15:35:35]

Done.

+    switch (format) {
+      case ETC1:
+        texture_compressor =
+            TextureCompressor::Create(TextureCompressor::kFormatETC1);

[christiank, 2015/09/30 07:49:42]

reveman (cited from 1197423003):
"hm, I think we should assume that creating a texture compressor instance is
expensive. can we use a process wide instance?"

Sure. It think singletons would work nicely, having a static
TextureCompressor::Get(<format>) function returning a lazily initialized
singleton compressor. But if I recall correctly Singletons are discouraged?

[reveman, 2015/09/30 09:55:15]

Creating it here each time is fine for now. Ideally we'd find an owner of these.
Maybe add a TextureCompressorProvider interface that gets passed here and is
implemented by LTHI. 

+        texture_compressor->Compress(reinterpret_cast<const uint8_t*>(
+                                         surface->peekPixels(nullptr, nullptr)),
+                                     reinterpret_cast<uint8_t*>(memory),
+                                     size.width(), size.height(),
+                                     TextureCompressor::kQualityHigh);
+        return;
+      case RGBA_8888:
+      case RGBA_4444:
+      case BGRA_8888:
+      case ALPHA_8:
+      case LUMINANCE_8:
+      case RGB_565:
+      case RED_8:
+        SkImageInfo dst_info = SkImageInfo::Make(
+            info.width(), info.height(), ResourceFormatToSkColorType(format),
+            info.alphaType(), info.profileType());
+        // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
+        // bitmap data. There will be no need to call SkAlign4 once
+        // crbug.com/293728
+        // is fixed.
+        const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
+        DCHECK_EQ(0u, dst_row_bytes % 4);
+        bool success =
+            canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
+        DCHECK_EQ(true, success);
+        return;
+    }
+
+    NOTREACHED();
   }
 }
 
 }  // namespace cc