Change GR_COMPRESS_ALPHA_MASK from compile-time flag to run-time flag

src/gpu/GrSWMaskHelper.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSWMaskHelper.h"
 
 #include "GrDrawState.h"
@@ skipping 48 matching lines @@
         default:
             SkDEBUGFAIL("No GrPixelConfig for compression format!");
             // Best guess
             config = kAlpha_8_GrPixelConfig;
             break;
     }
 
     return config;
 }
 
-#if GR_COMPRESS_ALPHA_MASK
 static bool choose_compressed_fmt(const GrDrawTargetCaps* caps,
                                   SkTextureCompressor::Format *fmt) {
     if (NULL == fmt) {
         return false;
     }
 
     // We can't use scratch textures without the ability to update
     // compressed textures...
     if (!(caps->compressedTexSubImageSupport())) {
         return false;
     }
 
     // Figure out what our preferred texture type is. If ASTC is available, that always
     // gives the biggest win. Otherwise, in terms of compression speed and accuracy,
     // LATC has a slight edge over R11 EAC.
     if (caps->isConfigTexturable(kASTC_12x12_GrPixelConfig)) {
         *fmt = SkTextureCompressor::kASTC_12x12_Format;
         return true;
     } else if (caps->isConfigTexturable(kLATC_GrPixelConfig)) {
         *fmt = SkTextureCompressor::kLATC_Format;
         return true;
     } else if (caps->isConfigTexturable(kR11_EAC_GrPixelConfig)) {
         *fmt = SkTextureCompressor::kR11_EAC_Format;
         return true;
     }
 
     return false;
 }
-#endif
 
 }
 
 /**
  * Draw a single rect element of the clip stack into the accumulation bitmap
  */
 void GrSWMaskHelper::draw(const SkRect& rect, SkRegion::Op op,
                           bool antiAlias, uint8_t alpha) {
     SkPaint paint;
 
@@ skipping 55 matching lines @@
     } else {
         fMatrix.setIdentity();
     }
 
     // Now translate so the bound's UL corner is at the origin
     fMatrix.postTranslate(-resultBounds.fLeft * SK_Scalar1,
                           -resultBounds.fTop * SK_Scalar1);
     SkIRect bounds = SkIRect::MakeWH(resultBounds.width(),
                                      resultBounds.height());
 
-#if GR_COMPRESS_ALPHA_MASK
-    if (choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) {
+    if (fContext->getOptions().fDrawPathToCompressedTexture &&
+        choose_compressed_fmt(fContext->getGpu()->caps(), &fCompressedFormat)) {
         fCompressionMode = kCompress_CompressionMode;
     }
-#endif
 
     // Make sure that the width is a multiple of the desired block dimensions
     // to allow for specialized SIMD instructions that compress multiple blocks at a time.
     int cmpWidth = bounds.fRight;
     int cmpHeight = bounds.fBottom;
     if (kCompress_CompressionMode == fCompressionMode) {
         int dimX, dimY;
         SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY);
         cmpWidth = dimX * ((cmpWidth + (dimX - 1)) / dimX);
         cmpHeight = dimY * ((cmpHeight + (dimY - 1)) / dimY);
@@ skipping 172 matching lines @@
     maskMatrix.preConcat(drawState->getViewMatrix());
 
     drawState->addCoverageEffect(
                          GrSimpleTextureEffect::Create(texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kPosition_GrCoordSet))->unref();
 
     target->drawSimpleRect(dstRect);
 }