Handle RGBA_4444 scales in > max texture size images

cc/tiles/gpu_image_decode_cache.cc

 // Copyright 2016 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/gpu_image_decode_cache.h"
 
 #include <inttypes.h>
 
 #include "base/auto_reset.h"
 #include "base/debug/alias.h"
@@ skipping 92 matching lines @@
   return MipMapUtil::GetScaleAdjustmentForLevel(base_size, mip_level);
 }
 
 // Calculates the size of a given mip level.
 gfx::Size CalculateSizeForMipLevel(const DrawImage& draw_image, int mip_level) {
   gfx::Size base_size(draw_image.image()->width(),
                       draw_image.image()->height());
   return MipMapUtil::GetSizeForLevel(base_size, mip_level);
 }
 
+// Draws and scales the provided |draw_image| into the |target_pixmap|. If the
+// draw/scale can be done directly, calls directly into SkImage::scalePixels,
+// if not, decodes to a compatible temporary pixmap and then converts that into
+// the |target_pixmap|.
+bool DrawAndScaleImage(const DrawImage& draw_image, SkPixmap* target_pixmap) {
+  const SkImage* image = draw_image.image().get();
+  if (image->dimensions() == target_pixmap->bounds().size() ||
+      target_pixmap->info().colorType() == kN32_SkColorType) {
+    // If no scaling is occurring, or if the target colortype is already N32,
+    // just scale directly.
+    return image->scalePixels(*target_pixmap,
+                              CalculateUploadScaleFilterQuality(draw_image),
+                              SkImage::kDisallow_CachingHint);
+  }
+
+  // If the target colortype is not N32, it may be impossible to scale
+  // directly. Instead scale into an N32 pixmap, and convert that into the
+  // |target_pixmap|.
+  SkImageInfo decode_info =
+      target_pixmap->info().makeColorType(kN32_SkColorType);
+  SkBitmap decode_bitmap;
+  if (!decode_bitmap.tryAllocPixels(decode_info))
+    return false;
+  SkPixmap decode_pixmap(decode_bitmap.info(), decode_bitmap.getPixels(),
+                         decode_bitmap.rowBytes());
+  if (!image->scalePixels(decode_pixmap,
+                          CalculateUploadScaleFilterQuality(draw_image),
+                          SkImage::kDisallow_CachingHint))
+    return false;
+  return decode_pixmap.readPixels(*target_pixmap);
+}
+
 }  // namespace
 
 // static
 GpuImageDecodeCache::InUseCacheKey
 GpuImageDecodeCache::InUseCacheKey::FromDrawImage(const DrawImage& draw_image) {
   return InUseCacheKey(draw_image);
 }
 
 // Extract the information to uniquely identify a DrawImage for the purposes of
 // the |in_use_cache_|.
@@ skipping 978 matching lines @@
       case DecodedDataMode::CPU: {
         SkImageInfo image_info = CreateImageInfoForDrawImage(
             draw_image, image_data->upload_params.fPreScaleMipLevel);
         // In order to match GPU scaling quality (which uses mip-maps at high
         // quality), we want to use at most medium filter quality for the
         // scale.
         SkPixmap image_pixmap(image_info.makeColorSpace(nullptr),
                               backing_memory->data(), image_info.minRowBytes());
         // Note that scalePixels falls back to readPixels if the scale is 1x, so
         // no need to special case that as an optimization.
-        if (!draw_image.image()->scalePixels(
-                image_pixmap, CalculateUploadScaleFilterQuality(draw_image),
-                SkImage::kDisallow_CachingHint)) {
+        if (!DrawAndScaleImage(draw_image, &image_pixmap)) {
           DLOG(ERROR) << "scalePixels failed.";
           backing_memory->Unlock();
           backing_memory.reset();
         }
         break;
       }
       case DecodedDataMode::GPU: {
         // TODO(crbug.com/649167): Params should not have changed since initial
         // sizing. Somehow this still happens. We should investigate and re-add
         // DCHECKs here to enforce this.
@@ skipping 221 matching lines @@
 
 void GpuImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   // Temporary changes |memory_state_| to free up cache as much as possible.
   base::AutoReset<base::MemoryState> reset(&memory_state_,
                                            base::MemoryState::SUSPENDED);
   EnsureCapacity(0);
 }
 
 }  // namespace cc