Use preferred format to allocate memory for decoded images

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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/tiles/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
@@ skipping 89 matching lines @@
       key.target_size().width() / static_cast<float>(key.src_rect().width());
   float y_scale =
       key.target_size().height() / static_cast<float>(key.src_rect().height());
   return SkSize::Make(x_scale, y_scale);
 }
 
 SkFilterQuality GetDecodedFilterQuality(const ImageDecodeControllerKey& key) {
   return std::min(key.filter_quality(), kLow_SkFilterQuality);
 }
 
+SkColorType SkColorTypeForDecoding(ResourceFormat format) {
+  // Use kN32_SkColorType if there is no corresponding SkColorType.
+  switch (format) {
+    case RGBA_4444:
+      return kARGB_4444_SkColorType;
+    case RGBA_8888:
+    case BGRA_8888:
+      return kN32_SkColorType;
+    case ALPHA_8:
+      return kAlpha_8_SkColorType;
+    case RGB_565:
+      return kRGB_565_SkColorType;
+    case LUMINANCE_8:

[reed1, 2016/03/17 14:38:23]

kGray_8_SkColorType

[bashi, 2016/03/17 23:29:38]

Done.

+    case ETC1:
+    case RED_8:
+    case LUMINANCE_F16:

[reed1, 2016/03/17 14:38:23]

BTW -- not hard for Skia to add native support for LUM_F16, if you think that is
common/important.

[bashi, 2016/03/17 23:29:38]

I'm not sure but I guess that LUM_16 is not common.

+      return kN32_SkColorType;
+  }
+  NOTREACHED();
+  return kN32_SkColorType;
+}
+
+SkImageInfo CreateImageInfo(size_t width,
+                            size_t height,
+                            ResourceFormat format) {
+  return SkImageInfo::Make(width, height, SkColorTypeForDecoding(format),
+                           kPremul_SkAlphaType);

[reed1, 2016/03/17 14:38:23]

FYI -- Skia is actively working on native support for kUnpremul for src images
(not surfaces), so hopefully this year we can relax this constraint.

+}
+
 }  // namespace
 
-SoftwareImageDecodeController::SoftwareImageDecodeController()
+SoftwareImageDecodeController::SoftwareImageDecodeController(
+    ResourceFormat format)
     : decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
       at_raster_decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
-      locked_images_budget_(kLockedMemoryLimitBytes) {}
+      locked_images_budget_(kLockedMemoryLimitBytes),
+      format_(format) {}
 
 SoftwareImageDecodeController::~SoftwareImageDecodeController() {
   DCHECK_EQ(0u, decoded_images_ref_counts_.size());
   DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
 }
 
 bool SoftwareImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& image,
     uint64_t prepare_tiles_id,
     scoped_refptr<ImageDecodeTask>* task) {
@@ skipping 212 matching lines @@
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::DecodeImageInternal", "key",
                key.ToString());
   const SkImage* image = draw_image.image();
 
   // If we can use the original decode, then we don't need to do scaling. We can
   // just read pixels into the final memory.
   if (key.can_use_original_decode()) {
     SkImageInfo decoded_info =
-        SkImageInfo::MakeN32Premul(image->width(), image->height());
+        CreateImageInfo(image->width(), image->height(), format_);
     scoped_ptr<base::DiscardableMemory> decoded_pixels;
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "SoftwareImageDecodeController::DecodeImageInternal - allocate "
           "decoded pixels");
       decoded_pixels =
           base::DiscardableMemoryAllocator::GetInstance()
               ->AllocateLockedDiscardableMemory(decoded_info.minRowBytes() *
                                                 decoded_info.height());
@@ skipping 48 matching lines @@
   DCHECK(result);
   if (key.src_rect() != full_image_rect) {
     result = decoded_pixmap.extractSubset(&decoded_pixmap,
                                           gfx::RectToSkIRect(key.src_rect()));
     DCHECK(result);
   }
 
   // Now we have a decoded_pixmap which represents the src_rect at the
   // original scale. All we need to do is scale it.
   DCHECK(!key.target_size().IsEmpty());
-  SkImageInfo scaled_info = SkImageInfo::MakeN32Premul(
-      key.target_size().width(), key.target_size().height());
+  SkImageInfo scaled_info = CreateImageInfo(
+      key.target_size().width(), key.target_size().height(), format_);
   scoped_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::DecodeImageInternal - allocate "
         "scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
@@ skipping 423 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc