Revert[4] of add ImageShader, sharing code with its Bitmap cousin

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 "GrTextureMaker.h"
 
 #include "SkGr.h"
@@ skipping 19 matching lines @@
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "effects/GrYUVtoRGBEffect.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "ktx.h"
 #  include "etc1.h"
 #endif
 
+bool GrTextureUsageSupported(const GrCaps& caps, int width, int height, SkImageUsageType usage) {
+    if (caps.npotTextureTileSupport()) {
+        return true;
+    }

[robertphillips, 2015/09/30 19:25:56]

isPow2 ?

+    const bool is_pow2 = SkIsPow2(width) && SkIsPow2(height);
+    return is_pow2 || kUntiled_SkImageUsageType == usage;
+}
+
+GrTextureParams GrImageUsageToTextureParams(SkImageUsageType usage) {

[bsalomon, 2015/09/30 19:21:12]

Maybe it's time to go the other way rather than expose this conversion?

+    // Just need a params that will trigger the correct cache key / etc, since the usage doesn't
+    // tell us the specifics about filter level or specific tiling.
+

[robertphillips, 2015/09/30 19:25:56]

Do we need some assert r.e. the number of image usage types matching the size of
'tiles' and 'filters' ?

+    const SkShader::TileMode tiles[] = {
+        SkShader::kClamp_TileMode,      // kUntiled_SkImageUsageType
+        SkShader::kRepeat_TileMode,     // kTiled_Unfiltered_SkImageUsageType
+        SkShader::kRepeat_TileMode,     // kTiled_Filtered_SkImageUsageType
+    };
+
+    const GrTextureParams::FilterMode filters[] = {
+        GrTextureParams::kNone_FilterMode,      // kUntiled_SkImageUsageType
+        GrTextureParams::kNone_FilterMode,      // kTiled_Unfiltered_SkImageUsageType
+        GrTextureParams::kBilerp_FilterMode,    // kTiled_Filtered_SkImageUsageType
+    };
+
+    return GrTextureParams(tiles[usage], filters[usage]);
+}
+
 /*  Fill out buffer with the compressed format Ganesh expects from a colortable
  based bitmap. [palette (colortable) + indices].
 
  At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
  we could detect that the colortable.count is <= 16, and then repack the
  indices as nibbles to save RAM, but it would take more time (i.e. a lot
  slower than memcpy), so skipping that for now.
 
  Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
  as the colortable.count says it is.
@@ skipping 76 matching lines @@
         } else {
             stretch->fType = SkGrStretch::kBilerp_Type;
         }
     } else {
         stretch->fWidth  = -1;
         stretch->fHeight = -1;
         stretch->fType = SkGrStretch::kNone_Type;
     }
 }
 
-static bool make_stretched_key(const GrUniqueKey& origKey, const SkGrStretch& stretch,
-                               GrUniqueKey* stretchedKey) {
+bool GrMakeStretchedKey(const GrUniqueKey& origKey, const SkGrStretch& stretch,
+                        GrUniqueKey* stretchedKey) {
     if (origKey.isValid() && SkGrStretch::kNone_Type != stretch.fType) {
         uint32_t width = SkToU16(stretch.fWidth);
         uint32_t height = SkToU16(stretch.fHeight);
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey::Builder builder(stretchedKey, origKey, kDomain, 2);
         builder[0] = stretch.fType;
         builder[1] = width | (height << 16);
         builder.finish();
         return true;
     }
@@ skipping 14 matching lines @@
 }
 
 void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& subset,
                           const GrCaps& caps, SkImageUsageType usage) {
     const SkGrStretch::Type stretches[] = {
         SkGrStretch::kNone_Type,        // kUntiled_SkImageUsageType
         SkGrStretch::kNearest_Type,     // kTiled_Unfiltered_SkImageUsageType
         SkGrStretch::kBilerp_Type,      // kTiled_Filtered_SkImageUsageType
     };
 
-    const bool isPow2 = SkIsPow2(subset.width()) && SkIsPow2(subset.height());
-    const bool needToStretch = !isPow2 &&
-                               usage != kUntiled_SkImageUsageType &&
-                               !caps.npotTextureTileSupport();
-
-    if (needToStretch) {
+    if (!GrTextureUsageSupported(caps, subset.width(), subset.height(), usage)) {
         GrUniqueKey tmpKey;
         make_unstretched_key(&tmpKey, imageID, subset);
 
         SkGrStretch stretch;
         stretch.fType = stretches[usage];
         stretch.fWidth = SkNextPow2(subset.width());
         stretch.fHeight = SkNextPow2(subset.height());
-        if (!make_stretched_key(tmpKey, stretch, key)) {
+        if (!GrMakeStretchedKey(tmpKey, stretch, key)) {
             goto UNSTRETCHED;
         }
     } else {
         UNSTRETCHED:
         make_unstretched_key(key, imageID, subset);
     }
 }
 
 static void make_image_keys(uint32_t imageID, const SkIRect& subset, const SkGrStretch& stretch,
                             GrUniqueKey* key, GrUniqueKey* stretchedKey) {
     make_unstretched_key(key, imageID, subset);
     if (SkGrStretch::kNone_Type != stretch.fType) {
-        make_stretched_key(*key, stretch, stretchedKey);
+        GrMakeStretchedKey(*key, stretch, stretchedKey);
     }
 }
 
 GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = info.width();
     desc.fHeight = info.height();
     desc.fConfig = SkImageInfo2GrPixelConfig(info);
     desc.fSampleCnt = 0;
@@ skipping 294 matching lines @@
     // Handle the case where the bitmap/image is explicitly texture backed.
     if (nativeTexture) {
         if (SkGrStretch::kNone_Type == stretch.fType) {
             return true;
         }
         const GrUniqueKey& key = nativeTexture->getUniqueKey();
         if (!key.isValid()) {
             return false;
         }
         GrUniqueKey stretchedKey;
-        make_stretched_key(key, stretch, &stretchedKey);
+        GrMakeStretchedKey(key, stretch, &stretchedKey);
         return ctx->textureProvider()->existsTextureWithUniqueKey(stretchedKey);
     }
 
     GrUniqueKey key, stretchedKey;
     make_image_keys(imageID, subset, stretch, &key, &stretchedKey);
     return ctx->textureProvider()->existsTextureWithUniqueKey(
         (SkGrStretch::kNone_Type == stretch.fType) ? key : stretchedKey);
 }
 
 class Bitmap_GrTextureMaker : public GrTextureMaker {
@@ skipping 20 matching lines @@
         return create_unstretched_bitmap_texture(ctx, fBitmap, unstretchedKey);
     }
 
     bool onMakeStretchedKey(const SkGrStretch& stretch, GrUniqueKey* stretchedKey) override {
         if (fBitmap.isVolatile()) {
             return false;
         }
 
         GrUniqueKey unstretchedKey;
         make_unstretched_key(&unstretchedKey, fBitmap.getGenerationID(), fBitmap.getSubset());
-        return make_stretched_key(unstretchedKey, stretch, stretchedKey);
+        return GrMakeStretchedKey(unstretchedKey, stretch, stretchedKey);
     }
 
     void onNotifyStretchCached(const GrUniqueKey& stretchedKey) override {
         fBitmap.pixelRef()->addGenIDChangeListener(new BitmapInvalidator(stretchedKey));
     }
 
     bool onGetROBitmap(SkBitmap* bitmap) override {
         *bitmap = fBitmap;
         return true;
     }
 
 private:
     const SkBitmap fBitmap;
 
     typedef GrTextureMaker INHERITED;
 };
 
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
     return Bitmap_GrTextureMaker(bitmap).refCachedTexture(ctx, params);
 }
 
 // TODO: make this be the canonical signature, and turn the version that takes GrTextureParams*
 //       into a wrapper that contains the inverse of these tables.
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     SkImageUsageType usage) {
-    // Just need a params that will trigger the correct cache key / etc, since the usage doesn't
-    // tell us the specifics about filter level or specific tiling.
-
-    const SkShader::TileMode tiles[] = {
-        SkShader::kClamp_TileMode,      // kUntiled_SkImageUsageType
-        SkShader::kRepeat_TileMode,     // kTiled_Unfiltered_SkImageUsageType
-        SkShader::kRepeat_TileMode,     // kTiled_Filtered_SkImageUsageType
-    };
-
-    const GrTextureParams::FilterMode filters[] = {
-        GrTextureParams::kNone_FilterMode,      // kUntiled_SkImageUsageType
-        GrTextureParams::kNone_FilterMode,      // kTiled_Unfiltered_SkImageUsageType
-        GrTextureParams::kBilerp_FilterMode,    // kTiled_Filtered_SkImageUsageType
-    };
-
-    GrTextureParams params(tiles[usage], filters[usage]);
+    GrTextureParams params = GrImageUsageToTextureParams(usage);
     return GrRefCachedBitmapTexture(ctx, bitmap, &params);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // alphatype is ignore for now, but if GrPixelConfig is expanded to encompass
 // alpha info, that will be considered.
 GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, SkColorProfileType pt) {
     switch (ct) {
         case kUnknown_SkColorType:
@@ skipping 293 matching lines @@
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
+GrTexture* GrTextureMaker::refCachedTexture(GrContext* ctx, SkImageUsageType usage) {
+    GrTextureParams params = GrImageUsageToTextureParams(usage);
+    return this->refCachedTexture(ctx, &params);
+}
+
 GrTexture* GrTextureMaker::refCachedTexture(GrContext* ctx, const GrTextureParams* params) {
     SkGrStretch stretch;
     get_stretch(ctx, this->width(), this->height(), params, &stretch);
 
     if (SkGrStretch::kNone_Type == stretch.fType) {
         return this->onRefUnstretchedTexture(ctx);
     }
 
     GrUniqueKey stretchedKey;
     if (this->onMakeStretchedKey(stretch, &stretchedKey)) {
@@ skipping 28 matching lines @@
         SkBitmap stretchedBmp = stretch_on_cpu(bitmap, stretch);
         return create_unstretched_bitmap_texture(ctx, stretchedBmp, GrUniqueKey());
     } else {
         SkAutoTUnref<GrTexture> unstretched(this->onRefUnstretchedTexture(ctx));
         if (!unstretched) {
             return nullptr;
         }
         return stretch_texture(unstretched, stretch, nullptr, GrUniqueKey());
     }
 }