Add whitelist parameter to refEncodedData

tests/ImageGeneratorTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkGraphics.h"
 #include "SkImageGenerator.h"
@@ skipping 53 matching lines @@
     sizeInfo.fWidthBytes[SkYUVSizeInfo::kV] = 250;
     int dummy;
     planes[SkYUVSizeInfo::kY] = planes[SkYUVSizeInfo::kU] = planes[SkYUVSizeInfo::kV] = &dummy;
     ig.getYUV8Planes(sizeInfo, planes);
 
     // Suppressed due to https://code.google.com/p/skia/issues/detail?id=4339
     if (false) {
         test_imagegenerator_factory(reporter);
     }
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+#if SK_SUPPORT_GPU
+#include "GrCaps.h"
+#include "GrContext.h"
+#include "Resources.h"
+#include "SkImageCacherator.h"
+
+static SkImageGenerator* new_from_encoded(sk_sp<SkData> data) {
+    SkASSERT(data);
+
+    SkImageGenerator* gen = SkImageGenerator::NewFromEncoded(data.get());
+    if (gen) {
+        return gen;
+    }
+
+    // FIXME: We do not currently have an SkImageGenerator that supports KTX, PKM, or ASTC. (We
+    // used to support them with SkImageDecoder, which has been deleted. We have not yet ported
+    // them to SkCodec: skbug.com/4971) For now, use a dummy class which still allows retrieving
+    // the encoded data.
+    class DummyGenerator final : public SkImageGenerator {
+    public:
+        DummyGenerator(sk_sp<SkData> data)
+        : INHERITED(SkImageInfo::MakeUnknown(1, 1))
+        , fData(std::move(data))
+        {}
+    protected:
+        SkData* onRefEncodedData(SK_REFENCODEDDATA_CTXPARAM) override {
+#ifndef SK_SUPPORT_LEGACY_REFENCODEDDATA_NOCTX
+            if (query) {
+                if (!query->supportedFormatFromData(fData->data(), fData->size())) {
+                    return nullptr;
+                }
+            }
+#endif
+            return SkRef(fData.get());
+        }
+    private:
+        sk_sp<SkData> fData;
+        typedef SkImageGenerator INHERITED;
+    };
+
+    return new DummyGenerator(data);
+}
+
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageGenerator_refEncodedData, reporter, ctxInfo) {
+    const struct {
+        const char*     fName;
+        SkEncodedFormat fFormat;
+        GrPixelConfig   fConfig;        // compressed config or kUnknown
+    } recs[] = {
+        { "mandrill_128.ktx",            kKTX_SkEncodedFormat,  kETC1_GrPixelConfig },
+        { "mandrill_128.pkm",            kPKM_SkEncodedFormat,  kETC1_GrPixelConfig },
+        { "mandrill_132x132_12x12.astc", kASTC_SkEncodedFormat, kASTC_12x12_GrPixelConfig },
+
+        // These have no compressed gpu config, so we expected them to not be supported (on gpu)
+        { "mandrill_128.png",            kPNG_SkEncodedFormat,  kUnknown_GrPixelConfig },
+        { "mandrill_128x128_4x4.astc",   kASTC_SkEncodedFormat, kUnknown_GrPixelConfig },
+    };
+
+    GrContext* context = ctxInfo.fGrContext;
+    SkEncodedFormatQuery_Gpu query(context);
+    const GrCaps* caps = context->caps();
+
+    for (const auto& r : recs) {
+        sk_sp<SkData> data(SkData::MakeFromFileName(GetResourcePath(r.fName).c_str()));
+        if (!data) {
+            SkDebugf("----- could not find resource %s\n", r.fName);
+            continue;
+        }
+        SkImageGenerator* gen = new_from_encoded(data);
+        SkAutoTDelete<SkImageCacherator> cacher(SkImageCacherator::NewFromGenerator(gen));
+
+        // we expect ALL formats to be supported on cpu
+        sk_sp<SkData> encData(cacher->refEncoded(nullptr));
+        bool cacherSupported = encData != nullptr;
+        REPORTER_ASSERT(reporter, cacherSupported);
+
+        // now test gpu
+        const bool capsSupported = caps->isConfigTexturable(r.fConfig);
+
+        encData.reset(cacher->refEncoded(context));
+        cacherSupported = encData != nullptr;
+        // test the internal query subclass
+        bool formatSupported = query.supportedFormat(r.fFormat);
+        bool dataSupported = query.supportedFormatFromData(data->data(), data->size());
+
+#ifndef SK_SUPPORT_LEGACY_REFENCODEDDATA_NOCTX
+        REPORTER_ASSERT(reporter, cacherSupported == capsSupported);
+#endif
+        REPORTER_ASSERT(reporter, dataSupported == capsSupported);
+        // format support is harder, since (for example) KTX format may contain may different
+        // configs. Hence we only require that if a format is supported, then the caps must agree.
+        if (formatSupported) {
+            REPORTER_ASSERT(reporter, capsSupported);
+        }
+
+        if (false) {    // used for testing
+            SkDebugf("caps=%d cacher=%d format=%d data=%d file=%s\n",
+                     capsSupported, cacherSupported, formatSupported, dataSupported, r.fName);
+        }
+    }
+}
+#endif