Decouple contrast boost from fake gamma.

src/gpu/text/GrTextUtils.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextUtils.h"
 
 #include "GrAtlasTextBlob.h"
@@ skipping 22 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
 static const int kLargeDFFontLimit = 384;
 #else
 static const int kLargeDFFontLimit = 2 * kLargeDFFontSize;
 #endif
 };
 
 void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
                               GrBatchFontCache* fontCache,
                               const SkSurfaceProps& props, const SkPaint& skPaint,
-                              GrColor color, SkPaint::FakeGamma fakeGamma,
+                              GrColor color, uint32_t fontWeightFlags,
                               const SkMatrix& viewMatrix,
                               const char text[], size_t byteLength,
                               SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     // Ensure the blob is set for bitmaptext
     blob->setHasBitmap();
 
     GrBatchTextStrike* currStrike = nullptr;
 
     // Get GrFontScaler from cache
-    SkGlyphCache* cache = blob->setupCache(runIndex, props, fakeGamma,
-                                           skPaint, &viewMatrix);
+    SkGlyphCache* cache = blob->setupCache(runIndex, props, fontWeightFlags, skPaint, &viewMatrix);
     GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
 
     SkFindAndPlaceGlyph::ProcessText(
         skPaint.getTextEncoding(), text, byteLength,
         {x, y}, viewMatrix, skPaint.getTextAlign(),
         cache,
         [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
             position += rounding;
             BmpAppendGlyph(
                 blob, runIndex, fontCache, &currStrike, glyph,
                 SkScalarFloorToInt(position.fX), SkScalarFloorToInt(position.fY),
                 color, fontScaler);
         }
     );
 
     SkGlyphCache::AttachCache(cache);
 }
 
 void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
                                  GrBatchFontCache* fontCache,
                                  const SkSurfaceProps& props, const SkPaint& skPaint,
-                                 GrColor color, SkPaint::FakeGamma fakeGamma,
+                                 GrColor color, uint32_t fontWeightFlags,
                                  const SkMatrix& viewMatrix,
                                  const char text[], size_t byteLength,
                                  const SkScalar pos[], int scalarsPerPosition,
                                  const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     // Ensure the blob is set for bitmaptext
     blob->setHasBitmap();
 
     GrBatchTextStrike* currStrike = nullptr;
 
     // Get GrFontScaler from cache
-    SkGlyphCache* cache = blob->setupCache(runIndex, props, fakeGamma,
-                                           skPaint, &viewMatrix);
+    SkGlyphCache* cache = blob->setupCache(runIndex, props, fontWeightFlags, skPaint, &viewMatrix);
     GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
 
     SkFindAndPlaceGlyph::ProcessPosText(
         skPaint.getTextEncoding(), text, byteLength,
         offset, viewMatrix, pos, scalarsPerPosition,
         skPaint.getTextAlign(), cache,
         [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
             position += rounding;
             BmpAppendGlyph(
                 blob, runIndex, fontCache, &currStrike, glyph,
@@ skipping 126 matching lines @@
     blob->setMinAndMaxScale(dfMaskScaleFloor / scaledTextSize, dfMaskScaleCeil / scaledTextSize);
 
     skPaint->setLCDRenderText(false);
     skPaint->setAutohinted(false);
     skPaint->setHinting(SkPaint::kNormal_Hinting);
     skPaint->setSubpixelText(true);
 }
 
 void GrTextUtils::DrawDFText(GrAtlasTextBlob* blob, int runIndex,
                              GrBatchFontCache* fontCache, const SkSurfaceProps& props,
-                             const SkPaint& skPaint, GrColor color, SkPaint::FakeGamma fakeGamma,
+                             const SkPaint& skPaint, GrColor color, uint32_t fontWeightFlags,
                              const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
                              SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != nullptr);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     SkPaint::GlyphCacheProc glyphCacheProc = skPaint.getGlyphCacheProc(true);
     SkAutoDescriptor desc;
     // We apply the fake-gamma by altering the distance in the shader, so we ignore the
-    // fakeGamma parameter. (It's only used when we fall-back to bitmap text).
-    skPaint.getScalerContextDescriptor(&desc, props, SkPaint::FakeGamma::Off, nullptr);
+    // passed-in font weight flags. (It's only used when we fall-back to bitmap text).
+    skPaint.getScalerContextDescriptor(&desc, props, SkPaint::kNone_FontWeightFlag, nullptr);
     SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(skPaint.getTypeface(),
                                                              desc.getDesc());
 
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
     SkScalar stopX = 0;
     SkScalar stopY = 0;
     SkScalar origin = 0;
     switch (skPaint.getTextAlign()) {
@@ skipping 29 matching lines @@
         alignX = SkScalarHalf(alignX);
         alignY = SkScalarHalf(alignY);
     } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
         alignX = 0;
         alignY = 0;
     }
     x -= alignX;
     y -= alignY;
     SkPoint offset = SkPoint::Make(x, y);
 
-    DrawDFPosText(blob, runIndex, fontCache, props, skPaint, color, fakeGamma, viewMatrix,
+    DrawDFPosText(blob, runIndex, fontCache, props, skPaint, color, fontWeightFlags, viewMatrix,
                   text, byteLength, positions.begin(), 2, offset);
 }
 
 void GrTextUtils::DrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
                                 GrBatchFontCache* fontCache, const SkSurfaceProps& props,
                                 const SkPaint& origPaint,
-                                GrColor color, SkPaint::FakeGamma fakeGamma,
+                                GrColor color, uint32_t fontWeightFlags,
                                 const SkMatrix& viewMatrix,
                                 const char text[], size_t byteLength,
                                 const SkScalar pos[], int scalarsPerPosition,
                                 const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == nullptr || byteLength == 0) {
         return;
     }
 
     SkTDArray<char> fallbackTxt;
     SkTDArray<SkScalar> fallbackPos;
 
     // Setup distance field paint and text ratio
     SkScalar textRatio;
     SkPaint dfPaint(origPaint);
     GrTextUtils::InitDistanceFieldPaint(blob, &dfPaint, &textRatio, viewMatrix);
     blob->setHasDistanceField();
     blob->setSubRunHasDistanceFields(runIndex, origPaint.isLCDRenderText());
 
     GrBatchTextStrike* currStrike = nullptr;
 
     // We apply the fake-gamma by altering the distance in the shader, so we ignore the
-    // fakeGamma parameter. (It's only used when we fall-back to bitmap text).
-    SkGlyphCache* cache = blob->setupCache(runIndex, props, SkPaint::FakeGamma::Off,
+    // passed-in font weight flags. (It's only used when we fall-back to bitmap text).
+    SkGlyphCache* cache = blob->setupCache(runIndex, props, SkPaint::kNone_FontWeightFlag,
                                            dfPaint, nullptr);
     SkPaint::GlyphCacheProc glyphCacheProc = dfPaint.getGlyphCacheProc(true);
     GrFontScaler* fontScaler = GrTextUtils::GetGrFontScaler(cache);
 
     const char* stop = text + byteLength;
 
     if (SkPaint::kLeft_Align == dfPaint.getTextAlign()) {
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
@@ skipping 53 matching lines @@
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
     SkGlyphCache::AttachCache(cache);
     if (fallbackTxt.count()) {
         blob->initOverride(runIndex);
         GrTextUtils::DrawBmpPosText(blob, runIndex, fontCache, props,
-                                    origPaint, origPaint.getColor(), fakeGamma, viewMatrix,
+                                    origPaint, origPaint.getColor(), fontWeightFlags, viewMatrix,
                                     fallbackTxt.begin(), fallbackTxt.count(),
                                     fallbackPos.begin(), scalarsPerPosition, offset);
     }
 }
 
 bool GrTextUtils::DfAppendGlyph(GrAtlasTextBlob* blob, int runIndex, GrBatchFontCache* cache,
                                 GrBatchTextStrike** strike, const SkGlyph& skGlyph,
                                 SkScalar sx, SkScalar sy, GrColor color,
                                 GrFontScaler* scaler,
                                 SkScalar textRatio, const SkMatrix& viewMatrix) {
@@ skipping 146 matching lines @@
     if (cache->getAuxProcData(glyph_cache_aux_proc, &auxData)) {
         scaler = (GrFontScaler*)auxData;
     }
     if (nullptr == scaler) {
         scaler = new GrFontScaler(cache);
         cache->setAuxProc(glyph_cache_aux_proc, scaler);
     }
 
     return scaler;
 }