Add prescale option to deferred params

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
+#include <vector>
 #include "DMGpuSupport.h"
 
 #include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImage_Base.h"
 #include "SkPicture.h"
@@ skipping 40 matching lines @@
     SkPaint paint;
     paint.setColor(SK_ColorBLACK);
     canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
 }
 static sk_sp<SkImage> create_image() {
     const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
     auto surface(SkSurface::MakeRaster(info));
     draw_image_test_pattern(surface->getCanvas());
     return surface->makeImageSnapshot();
 }
+static sk_sp<SkImage> create_image_large() {
+    const SkImageInfo info = SkImageInfo::MakeN32(32000, 32, kOpaque_SkAlphaType);
+    auto surface(SkSurface::MakeRaster(info));
+    surface->getCanvas()->clear(SK_ColorWHITE);
+    SkPaint paint;
+    paint.setColor(SK_ColorBLACK);
+    surface->getCanvas()->drawRect(SkRect::MakeXYWH(4000, 2, 28000, 30), paint);
+    return surface->makeImageSnapshot();
+}
 
 static SkData* create_image_data(SkImageInfo* info) {
     *info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
     const size_t rowBytes = info->minRowBytes();
     SkAutoTUnref<SkData> data(SkData::NewUninitialized(rowBytes * info->height()));
     {
         SkBitmap bm;
         bm.installPixels(*info, data->writable_data(), rowBytes);
         SkCanvas canvas(bm);
         draw_image_test_pattern(&canvas);
@@ skipping 750 matching lines @@
     sk_gpu_test::TestContext* testContext = ctxInfo.testContext();
     SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy());
 
     GrContextFactory otherFactory;
     ContextInfo otherContextInfo =
         otherFactory.getContextInfo(GrContextFactory::kNativeGL_ContextType);
 
     testContext->makeCurrent();
     REPORTER_ASSERT(reporter, proxy);
     struct {
-        std::function<sk_sp<SkImage> ()> fImageFactory;
-        bool                       fExpectation;
+        std::function<sk_sp<SkImage> ()>                      fImageFactory;
+        std::vector<SkImage::DeferredTextureImageUsageParams> fParams;
+        SkFilterQuality                                       fExpectedQuality;
+        int                                                   fExpectedScaleFactor;
+        bool                                                  fExpectation;
     } testCases[] = {
-        { create_image,          true },
-        { create_codec_image,    true },
-        { create_data_image,     true },
-        { create_picture_image,  false },
-        { [context] { return create_gpu_image(context); }, false },
+        { create_image,          {{}}, kNone_SkFilterQuality, 1, true },
+        { create_codec_image,    {{}}, kNone_SkFilterQuality, 1, true },
+        { create_data_image,     {{}}, kNone_SkFilterQuality, 1, true },
+        { create_picture_image,  {{}}, kNone_SkFilterQuality, 1, false },
+        { [context] { return create_gpu_image(context); }, {{}}, kNone_SkFilterQuality, 1, false },
         // Create a texture image in a another GrContext.
         { [testContext, otherContextInfo] {
             otherContextInfo.testContext()->makeCurrent();
             sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
             testContext->makeCurrent();
             return otherContextImage;
-          }, false },
+          }, {{}}, kNone_SkFilterQuality, 1, false },
+        // Create an image that is too large to upload.
+        { create_image_large,    {{}}, kNone_SkFilterQuality, 1, false },
+        // Create an image that is too large, but is scaled to an acceptable size.
+        { create_image_large, {{SkMatrix::I(), kMedium_SkFilterQuality, 4}},
+          kMedium_SkFilterQuality, 16, true},
+        // Create an image with multiple low filter qualities, make sure we round up.
+        { create_image_large, {{SkMatrix::I(), kNone_SkFilterQuality, 4},
+                               {SkMatrix::I(), kMedium_SkFilterQuality, 4}},
+          kMedium_SkFilterQuality, 16, true},
+        // Create an image with multiple prescale levels, make sure we chose the minimum scale.
+        { create_image_large, {{SkMatrix::I(), kMedium_SkFilterQuality, 5},
+                               {SkMatrix::I(), kMedium_SkFilterQuality, 4}},
+          kMedium_SkFilterQuality, 16, true},
     };
 
 
     for (auto testCase : testCases) {
         sk_sp<SkImage> image(testCase.fImageFactory());
-
-        // This isn't currently used in the implementation, just set any old values.
-        SkImage::DeferredTextureImageUsageParams params;
-        params.fQuality = kLow_SkFilterQuality;
-        params.fMatrix = SkMatrix::I();
-
-        size_t size = image->getDeferredTextureImageData(*proxy, &params, 1, nullptr);
+        size_t size = image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
+                                                         static_cast<int>(testCase.fParams.size()),
+                                                         nullptr);
 
         static const char *const kFS[] = { "fail", "succeed" };
         if (SkToBool(size) != testCase.fExpectation) {
             ERRORF(reporter,  "This image was expected to %s but did not.",
                    kFS[testCase.fExpectation]);
         }
         if (size) {
             void* buffer = sk_malloc_throw(size);
             void* misaligned = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(buffer) + 3);
-            if (image->getDeferredTextureImageData(*proxy, &params, 1, misaligned)) {
+            if (image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
+                                                   static_cast<int>(testCase.fParams.size()),
+                                                   misaligned)) {
                 ERRORF(reporter, "Should fail when buffer is misaligned.");
             }
-            if (!image->getDeferredTextureImageData(*proxy, &params, 1, buffer)) {
+            if (!image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
+                                                    static_cast<int>(testCase.fParams.size()),
+                                                    buffer)) {
                 ERRORF(reporter, "deferred image size succeeded but creation failed.");
             } else {
                 for (auto budgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
                     sk_sp<SkImage> newImage(
                         SkImage::MakeFromDeferredTextureImageData(context, buffer, budgeted));
                     REPORTER_ASSERT(reporter, newImage != nullptr);
                     if (newImage) {
-                        check_images_same(reporter, image.get(), newImage.get());
+                        // Scale the image in software for comparison.
+                        SkImageInfo scaled_info = SkImageInfo::MakeN32(
+                                image->width() / testCase.fExpectedScaleFactor,
+                                image->height() / testCase.fExpectedScaleFactor,
+                                image->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
+                        SkAutoPixmapStorage scaled;
+                        scaled.alloc(scaled_info);
+                        image->scalePixels(scaled, testCase.fExpectedQuality);
+                        sk_sp<SkImage> scaledImage = SkImage::MakeRasterCopy(scaled);
+                        check_images_same(reporter, scaledImage.get(), newImage.get());
                     }
                     // The other context should not be able to create images from texture data
                     // created by the original context.
                     sk_sp<SkImage> newImage2(SkImage::MakeFromDeferredTextureImageData(
                         otherContextInfo.grContext(), buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
                     testContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif