Store mipmap levels in deferred texture image

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>
@@ skipping 870 matching lines @@
 
     testContext->makeCurrent();
     REPORTER_ASSERT(reporter, proxy);
     struct {
         std::function<sk_sp<SkImage> ()>                      fImageFactory;
         std::vector<SkImage::DeferredTextureImageUsageParams> fParams;
         SkFilterQuality                                       fExpectedQuality;
         int                                                   fExpectedScaleFactor;
         bool                                                  fExpectation;
     } testCases[] = {
-        { 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_image,          {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          kNone_SkFilterQuality, 1, true },
+        { create_codec_image,    {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          kNone_SkFilterQuality, 1, true },
+        { create_data_image,     {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          kNone_SkFilterQuality, 1, true },
+        { create_picture_image,  {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          kNone_SkFilterQuality, 1, false },
+        { [context] { return create_gpu_image(context); },
+          {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          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;
-          }, {{}}, kNone_SkFilterQuality, 1, false },
+          }, {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+        kNone_SkFilterQuality, 1, false },
         // Create an image that is too large to upload.
-        { create_image_large,    {{}}, kNone_SkFilterQuality, 1, false },
+        { create_image_large,    {{SkMatrix::I(), kNone_SkFilterQuality, 0}},
+          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());
         size_t size = image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
                                                          static_cast<int>(testCase.fParams.size()),
-                                                         nullptr);
-
+                                                         nullptr, SkSourceGammaTreatment::kIgnore);
         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, testCase.fParams.data(),
                                                    static_cast<int>(testCase.fParams.size()),
-                                                   misaligned)) {
+                                                   misaligned, SkSourceGammaTreatment::kIgnore)) {
                 ERRORF(reporter, "Should fail when buffer is misaligned.");
             }
             if (!image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
                                                     static_cast<int>(testCase.fParams.size()),
-                                                    buffer)) {
+                                                    buffer, SkSourceGammaTreatment::kIgnore)) {
                 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) {
                         // Scale the image in software for comparison.
                         SkImageInfo scaled_info = SkImageInfo::MakeN32(
                                                     image->width() / testCase.fExpectedScaleFactor,
@@ skipping 65 matching lines @@
     SkBitmap bm1;
     bm1.allocPixels(SkImageInfo::MakeN32(256, 256, kUnpremul_SkAlphaType));
     bm0.readPixels(bm1.info(), bm1.getPixels(), bm1.rowBytes(), 0, 0);
 
     SkBitmap bm2;
     bm2.allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
     bm1.readPixels(bm2.info(), bm2.getPixels(), bm2.rowBytes(), 0, 0);
 
     REPORTER_ASSERT(reporter, equal(bm0, bm2));
 }