Revert of Gamma correction for distance field text.

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 1796 matching lines @@
 }
 
 #define MIN_SIZE_FOR_EFFECT_BUFFER  1024
 
 #ifdef SK_DEBUG
     #define TEST_DESC
 #endif
 
 /*
  *  ignoreGamma tells us that the caller just wants metrics that are unaffected
- *  by gamma correction, so we set the rec to ignore preblend: i.e. gamma = 1,
- *  contrast = 0, luminanceColor = transparent black.
+ *  by gamma correction, so we jam the luminance field to 0 (most common value
+ *  for black text) in hopes that we get a cache hit easier. A better solution
+ *  would be for the fontcache lookup to know to ignore the luminance field
+ *  entirely, but not sure how to do that and keep it fast.
  */
 void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
                              const SkMatrix* deviceMatrix,
                              void (*proc)(SkTypeface*, const SkDescriptor*, void*),
                              void* context, bool ignoreGamma) const {
     SkScalerContext::Rec    rec;
 
     SkScalerContext::MakeRec(*this, deviceProperties, deviceMatrix, &rec);
     if (ignoreGamma) {
-        rec.ignorePreBlend();
+        rec.setLuminanceColor(0);
     }
 
     size_t          descSize = sizeof(rec);
     int             entryCount = 1;
     SkPathEffect*   pe = this->getPathEffect();
     SkMaskFilter*   mf = this->getMaskFilter();
     SkRasterizer*   ra = this->getRasterizer();
 
     SkWriteBuffer    peBuffer, mfBuffer, raBuffer;
 
@@ skipping 103 matching lines @@
         desc2->computeChecksum();
         SkASSERT(!memcmp(desc, desc1, descSize));
         SkASSERT(!memcmp(desc, desc2, descSize));
     }
 #endif
 
     proc(fTypeface, desc, context);
 }
 
 SkGlyphCache* SkPaint::detachCache(const SkDeviceProperties* deviceProperties,
-                                   const SkMatrix* deviceMatrix,
-                                   bool ignoreGamma) const {
+                                   const SkMatrix* deviceMatrix) const {
     SkGlyphCache* cache;
-    this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, ignoreGamma);
+    this->descriptorProc(deviceProperties, deviceMatrix, DetachDescProc, &cache, false);
     return cache;
 }
 
 /**
  * Expands fDeviceGamma, fPaintGamma, fContrast, and fLumBits into a mask pre-blend.
  */
 //static
 SkMaskGamma::PreBlend SkScalerContext::GetMaskPreBlend(const SkScalerContext::Rec& rec) {
     SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
     const SkMaskGamma& maskGamma = cachedMaskGamma(rec.getContrast(),
                                                    rec.getPaintGamma(),
                                                    rec.getDeviceGamma());
     return maskGamma.preBlend(rec.getLuminanceColor());
 }
 
-size_t SkScalerContext::GetGammaLUTSize(SkScalar contrast, SkScalar paintGamma,
-                                        SkScalar deviceGamma, int* width, int* height) {
-    SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
-    const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
-                                                   paintGamma,
-                                                   deviceGamma);
-
-    maskGamma.getGammaTableDimensions(width, height);
-    size_t size = (*width)*(*height)*sizeof(uint8_t);
-
-    return size;
-}
-
-void SkScalerContext::GetGammaLUTData(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma,
-                                      void* data) {
-    SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
-    const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
-                                                   paintGamma,
-                                                   deviceGamma);
-    int width, height;
-    maskGamma.getGammaTableDimensions(&width, &height);
-    size_t size = width*height*sizeof(uint8_t);
-    const uint8_t* gammaTables = maskGamma.getGammaTables();
-    memcpy(data, gammaTables, size);
-}
-
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static uintptr_t asint(const void* p) {
     return reinterpret_cast<uintptr_t>(p);
 }
 
 union Scalar32 {
     SkScalar    fScalar;
@@ skipping 568 matching lines @@
         }
     } else {
         fScale = SK_Scalar1;
     }
 
     if (!applyStrokeAndPathEffects) {
         fPaint.setStyle(SkPaint::kFill_Style);
         fPaint.setPathEffect(NULL);
     }
 
-    fCache = fPaint.detachCache(NULL, NULL, false);
+    fCache = fPaint.detachCache(NULL, NULL);
 
     SkPaint::Style  style = SkPaint::kFill_Style;
     SkPathEffect*   pe = NULL;
 
     if (!applyStrokeAndPathEffects) {
         style = paint.getStyle();   // restore
         pe = paint.getPathEffect();     // restore
     }
     fPaint.setStyle(style);
     fPaint.setPathEffect(pe);
@@ skipping 158 matching lines @@
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }