Add whitelist parameter to refEncodedData

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGr.h"
 #include "SkGrPriv.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
 #include "SkData.h"
+#include "SkEncodedFormat.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTemplates.h"
 #include "SkTextureCompressor.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
@@ skipping 24 matching lines @@
     SkASSERT(!imageBounds.isEmpty());
     static const GrUniqueKey::Domain kImageIDDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kImageIDDomain, 5);
     builder[0] = imageID;
     builder[1] = imageBounds.fLeft;
     builder[2] = imageBounds.fTop;
     builder[3] = imageBounds.fRight;
     builder[4] = imageBounds.fBottom;
 }
 
+bool GrIsCompressedFormatPossiblySupported(GrContext* ctx, SkEncodedFormat format) {
+#ifndef SK_IGNORE_ETC1_SUPPORT
+    if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
+        return false;
+    }
+    switch (format) {
+        case kPKM_SkEncodedFormat:  // file format for ETC1
+            return true;
+        default:
+            return false;
+    }
+#endif
+    return false;
+}
+
+bool GrIsCompressedTextureDataPossiblySupported(GrContext* ctx, const void* data, size_t size) {
+#ifndef SK_IGNORE_ETC1_SUPPORT
+    if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
+        return false;
+    }
+
+    const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data);
+    if (size > ETC_PKM_HEADER_SIZE && etc1_pkm_is_valid(bytes)) {
+        return true;
+    } else if (SkKTXFile::is_ktx(bytes, size)) {
+        return true;
+    }
+#endif
+    return false;
+}
+
 GrPixelConfig GrIsCompressedTextureDataSupported(GrContext* ctx, SkData* data,
                                                  int expectedW, int expectedH,
                                                  const void** outStartOfDataToUpload) {
     *outStartOfDataToUpload = nullptr;
 #ifndef SK_IGNORE_ETC1_SUPPORT
     if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
         return kUnknown_GrPixelConfig;
     }
 
     const uint8_t* bytes = data->bytes();
     if (data->size() > ETC_PKM_HEADER_SIZE && etc1_pkm_is_valid(bytes)) {
         // Does the data match the dimensions of the bitmap? If not,
         // then we don't know how to scale the image to match it...
         if (etc1_pkm_get_width(bytes) != (unsigned)expectedW ||
             etc1_pkm_get_height(bytes) != (unsigned)expectedH)
         {
             return kUnknown_GrPixelConfig;
         }
 
         *outStartOfDataToUpload = bytes + ETC_PKM_HEADER_SIZE;
         return kETC1_GrPixelConfig;
-    } else if (SkKTXFile::is_ktx(bytes)) {
+    } else if (SkKTXFile::is_ktx(bytes, data->size())) {
         SkKTXFile ktx(data);
 
         // Is it actually an ETC1 texture?
         if (!ktx.isCompressedFormat(SkTextureCompressor::kETC1_Format)) {
             return kUnknown_GrPixelConfig;
         }
 
         // Does the data match the dimensions of the bitmap? If not,
         // then we don't know how to scale the image to match it...
         if (ktx.width() != expectedW || ktx.height() != expectedH) {
@@ skipping 655 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }