Change #def to be opt-out

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 "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkData.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "GrResourceCache.h"
 #include "GrGpu.h"
 #include "GrDrawTargetCaps.h"
 
-#if SK_SUPPORT_ETC1
+#ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "etc1.h"
 #endif
 
 /*  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.
@@ skipping 95 matching lines @@
     }
 };
 
 }  // namespace
 
 static void add_genID_listener(GrResourceKey key, SkPixelRef* pixelRef) {
     SkASSERT(NULL != pixelRef);
     pixelRef->addGenIDChangeListener(SkNEW_ARGS(GrResourceInvalidator, (key)));
 }
 
-#if SK_SUPPORT_ETC1
+#ifndef SK_IGNORE_ETC1_SUPPORT
 static GrTexture *load_etc1_texture(GrContext* ctx,
                                     const GrTextureParams* params,
                                     const SkBitmap &bm, GrTextureDesc desc) {
     SkData *data = bm.pixelRef()->refEncodedData();
 
     // Is this even encoded data?
     if (NULL == data) {
         return NULL;
     }
 
@@ skipping 21 matching lines @@
     GrCacheID cacheID;
     generate_bitmap_cache_id(bm, &cacheID);
 
     GrResourceKey key;
     GrTexture* result = ctx->createTexture(params, desc, cacheID, bytes, 0, &key);
     if (NULL != result) {
         add_genID_listener(key, bm.pixelRef());
     }
     return result;
 }
-#endif   // SK_SUPPORT_ETC1
+#endif   // SK_IGNORE_ETC1_SUPPORT
 
 static GrTexture* sk_gr_create_bitmap_texture(GrContext* ctx,
                                               bool cache,
                                               const GrTextureParams* params,
                                               const SkBitmap& origBitmap) {
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrTextureDesc desc;
@@ skipping 32 matching lines @@
             }
         } else {
             origBitmap.copyTo(&tmpBitmap, kN32_SkColorType);
             // now bitmap points to our temp, which has been promoted to 32bits
             bitmap = &tmpBitmap;
             desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info());
         }
     }
 
     // Is this an ETC1 encoded texture?
-#if SK_SUPPORT_ETC1
+#ifndef SK_IGNORE_ETC1_SUPPORT
     else if (cache && ctx->getGpu()->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
         GrTexture *texture = load_etc1_texture(ctx, params, *bitmap, desc);
         if (NULL != texture) {
             return texture;
         }
     }
-#endif   // SK_SUPPORT_ETC1
+#endif   // SK_IGNORE_ETC1_SUPPORT
 
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
     if (cache) {
         // This texture is likely to be used again so leave it in the cache
         GrCacheID cacheID;
         generate_bitmap_cache_id(origBitmap, &cacheID);
 
@@ skipping 246 matching lines @@
             copy.setShader(NULL);
             // modulate the paint alpha by the shader's solid color alpha
             U8CPU newA = SkMulDiv255Round(SkColorGetA(color), copy.getAlpha());
             copy.setColor(SkColorSetA(color, newA));
             SkPaint2GrPaintNoShader(context, copy, false, constantColor, grPaint);
         } else {
             SkPaint2GrPaintNoShader(context, skPaint, false, constantColor, grPaint);
         }
     }
 }