Decouple contrast boost from fake gamma.

src/gpu/text/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrContext.h"
 #include "GrDrawContext.h"
@@ skipping 35 matching lines @@
         // gamma corrected masks anyways, nor color
         U8CPU lum = SkComputeLuminance(SkColorGetR(canonicalColor),
                                        SkColorGetG(canonicalColor),
                                        SkColorGetB(canonicalColor));
         // reduce to our finite number of bits
         canonicalColor = SkMaskGamma::CanonicalColor(SkColorSetRGB(lum, lum, lum));
     }
     return canonicalColor;
 }
 
-SkPaint::FakeGamma GrAtlasTextContext::ComputeFakeGamma(GrDrawContext* dc, const GrPaint& grPaint) {
+uint32_t GrAtlasTextContext::ComputeScalerContextFlags(GrDrawContext* dc, const GrPaint& grPaint) {
     // If we're rendering to an sRGB render target, and we aren't forcing sRGB blending off,
-    // then we can disable the gamma hacks. Otherwise, leave them on:
+    // then we can disable the gamma hacks. Otherwise, leave them on. In either case, we still
+    // want the contrast boost:
     if (GrPixelConfigIsSRGB(dc->accessRenderTarget()->config()) &&
         !grPaint.getDisableOutputConversionToSRGB()) {
-        return SkPaint::FakeGamma::Off;
+        return SkPaint::kBoostContrast_ScalerContextFlag;
     } else {
-        return SkPaint::FakeGamma::On;
+        return SkPaint::kFakeGammaAndBoostContrast_ScalerContextFlags;
     }
 }
 
 // TODO if this function ever shows up in profiling, then we can compute this value when the
 // textblob is being built and cache it.  However, for the time being textblobs mostly only have 1
 // run so this is not a big deal to compute here.
 bool GrAtlasTextContext::HasLCD(const SkTextBlob* blob) {
     SkTextBlobRunIterator it(blob);
     for (; !it.done(); it.next()) {
         if (it.isLCD()) {
@@ skipping 46 matching lines @@
         cacheBlob.reset(SkSafeRef(cache->find(key)));
     }
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     if (!SkPaintToGrPaint(context, skPaint, viewMatrix, props.allowSRGBInputs(), &grPaint)) {
         return;
     }
 
-    SkPaint::FakeGamma fakeGamma = ComputeFakeGamma(dc, grPaint);
+    uint32_t scalerContextFlags = ComputeScalerContextFlags(dc, grPaint);
 
     if (cacheBlob) {
         if (cacheBlob->mustRegenerate(skPaint, grPaint.getColor(), blurRec, viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
             cache->remove(cacheBlob);
             cacheBlob.reset(SkRef(cache->createCachedBlob(blob, key, blurRec, skPaint)));
             RegenerateTextBlob(cacheBlob, context->getBatchFontCache(),
                                *context->caps()->shaderCaps(), skPaint, grPaint.getColor(),
-                               fakeGamma, viewMatrix, props,
+                               scalerContextFlags, viewMatrix, props,
                                blob, x, y, drawFilter);
         } else {
             cache->makeMRU(cacheBlob);
 
             if (CACHE_SANITY_CHECK) {
                 int glyphCount = 0;
                 int runCount = 0;
                 GrTextBlobCache::BlobGlyphCount(&glyphCount, &runCount, blob);
                 SkAutoTUnref<GrAtlasTextBlob> sanityBlob(cache->createBlob(glyphCount, runCount));
                 sanityBlob->setupKey(key, blurRec, skPaint);
                 RegenerateTextBlob(sanityBlob, context->getBatchFontCache(),
                                    *context->caps()->shaderCaps(), skPaint,
-                                   grPaint.getColor(), fakeGamma, viewMatrix, props,
+                                   grPaint.getColor(), scalerContextFlags, viewMatrix, props,
                                    blob, x, y, drawFilter);
                 GrAtlasTextBlob::AssertEqual(*sanityBlob, *cacheBlob);
             }
         }
     } else {
         if (canCache) {
             cacheBlob.reset(SkRef(cache->createCachedBlob(blob, key, blurRec, skPaint)));
         } else {
             cacheBlob.reset(cache->createBlob(blob));
         }
         RegenerateTextBlob(cacheBlob, context->getBatchFontCache(),
                            *context->caps()->shaderCaps(), skPaint, grPaint.getColor(),
-                           fakeGamma, viewMatrix, props,
+                           scalerContextFlags, viewMatrix, props,
                            blob, x, y, drawFilter);
     }
 
     cacheBlob->flushCached(context, dc, blob, props, fDistanceAdjustTable, skPaint,
                            grPaint, drawFilter, clip, viewMatrix, clipBounds, x, y);
 }
 
 void GrAtlasTextContext::RegenerateTextBlob(GrAtlasTextBlob* cacheBlob,
                                             GrBatchFontCache* fontCache,
                                             const GrShaderCaps& shaderCaps,
                                             const SkPaint& skPaint, GrColor color,
-                                            SkPaint::FakeGamma fakeGamma,
+                                            uint32_t scalerContextFlags,
                                             const SkMatrix& viewMatrix,
                                             const SkSurfaceProps& props,
                                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                                             SkDrawFilter* drawFilter) {
     cacheBlob->initReusableBlob(color, viewMatrix, x, y);
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlobRunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
@@ skipping 11 matching lines @@
         }
 
         runPaint.setFlags(GrTextUtils::FilterTextFlags(props, runPaint));
 
         cacheBlob->push_back_run(run);
 
         if (GrTextUtils::CanDrawAsDistanceFields(runPaint, viewMatrix, props, shaderCaps)) {
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning: {
                     GrTextUtils::DrawDFText(cacheBlob, run, fontCache,
-                                            props, runPaint, color, fakeGamma, viewMatrix,
-                                            (const char *)it.glyphs(), textLen,
+                                            props, runPaint, color, scalerContextFlags,
+                                            viewMatrix, (const char *)it.glyphs(), textLen,
                                             x + offset.x(), y + offset.y());
                     break;
                 }
                 case SkTextBlob::kHorizontal_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
                     GrTextUtils::DrawDFPosText(cacheBlob, run, fontCache,
-                                               props, runPaint, color, fakeGamma, viewMatrix,
-                                               (const char*)it.glyphs(), textLen, it.pos(),
-                                               1, dfOffset);
+                                               props, runPaint, color, scalerContextFlags,
+                                               viewMatrix, (const char*)it.glyphs(), textLen,
+                                               it.pos(), 1, dfOffset);
                     break;
                 }
                 case SkTextBlob::kFull_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y);
                     GrTextUtils::DrawDFPosText(cacheBlob, run,  fontCache,
-                                               props, runPaint, color, fakeGamma, viewMatrix,
-                                               (const char*)it.glyphs(), textLen, it.pos(),
-                                               2, dfOffset);
+                                               props, runPaint, color, scalerContextFlags,
+                                               viewMatrix, (const char*)it.glyphs(), textLen,
+                                               it.pos(), 2, dfOffset);
                     break;
                 }
             }
         } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->setRunDrawAsPaths(run);
         } else {
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning:
                     GrTextUtils::DrawBmpText(cacheBlob, run, fontCache,
-                                             props, runPaint, color, fakeGamma, viewMatrix,
-                                             (const char *)it.glyphs(), textLen,
+                                             props, runPaint, color, scalerContextFlags,
+                                             viewMatrix, (const char *)it.glyphs(), textLen,
                                              x + offset.x(), y + offset.y());
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
                     GrTextUtils::DrawBmpPosText(cacheBlob, run, fontCache,
-                                                props, runPaint, color, fakeGamma, viewMatrix,
-                                                (const char*)it.glyphs(), textLen, it.pos(), 1,
-                                                SkPoint::Make(x, y + offset.y()));
+                                                props, runPaint, color, scalerContextFlags,
+                                                viewMatrix, (const char*)it.glyphs(), textLen,
+                                                it.pos(), 1, SkPoint::Make(x, y + offset.y()));
                     break;
                 case SkTextBlob::kFull_Positioning:
                     GrTextUtils::DrawBmpPosText(cacheBlob, run, fontCache,
-                                                props, runPaint, color, fakeGamma, viewMatrix,
-                                                (const char*)it.glyphs(), textLen, it.pos(), 2,
-                                                SkPoint::Make(x, y));
+                                                props, runPaint, color, scalerContextFlags,
+                                                viewMatrix, (const char*)it.glyphs(), textLen,
+                                                it.pos(), 2, SkPoint::Make(x, y));
                     break;
             }
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
     }
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::CreateDrawTextBlob(GrTextBlobCache* blobCache,
                                        GrBatchFontCache* fontCache,
                                        const GrShaderCaps& shaderCaps,
                                        const GrPaint& paint,
                                        const SkPaint& skPaint,
-                                       SkPaint::FakeGamma fakeGamma,
+                                       uint32_t scalerContextFlags,
                                        const SkMatrix& viewMatrix,
                                        const SkSurfaceProps& props,
                                        const char text[], size_t byteLength,
                                        SkScalar x, SkScalar y) {
     int glyphCount = skPaint.countText(text, byteLength);
 
     GrAtlasTextBlob* blob = blobCache->createBlob(glyphCount, 1);
     blob->initThrowawayBlob(viewMatrix, x, y);
 
     if (GrTextUtils::CanDrawAsDistanceFields(skPaint, viewMatrix, props, shaderCaps)) {
-        GrTextUtils::DrawDFText(blob, 0, fontCache, props,
-                                skPaint, paint.getColor(), fakeGamma, viewMatrix, text,
-                                byteLength, x, y);
+        GrTextUtils::DrawDFText(blob, 0, fontCache, props, skPaint, paint.getColor(),
+                                scalerContextFlags, viewMatrix, text, byteLength, x, y);
     } else {
-        GrTextUtils::DrawBmpText(blob, 0, fontCache, props, skPaint,
-                                 paint.getColor(), fakeGamma, viewMatrix, text, byteLength, x, y);
+        GrTextUtils::DrawBmpText(blob, 0, fontCache, props, skPaint, paint.getColor(),
+                                 scalerContextFlags, viewMatrix, text, byteLength, x, y);
     }
     return blob;
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::CreateDrawPosTextBlob(GrTextBlobCache* blobCache, GrBatchFontCache* fontCache,
                                           const GrShaderCaps& shaderCaps, const GrPaint& paint,
-                                          const SkPaint& skPaint, SkPaint::FakeGamma fakeGamma,
+                                          const SkPaint& skPaint, uint32_t scalerContextFlags,
                                           const SkMatrix& viewMatrix, const SkSurfaceProps& props,
                                           const char text[], size_t byteLength,
                                           const SkScalar pos[], int scalarsPerPosition,
                                           const SkPoint& offset) {
     int glyphCount = skPaint.countText(text, byteLength);
 
     GrAtlasTextBlob* blob = blobCache->createBlob(glyphCount, 1);
     blob->initThrowawayBlob(viewMatrix, offset.x(), offset.y());
 
     if (GrTextUtils::CanDrawAsDistanceFields(skPaint, viewMatrix, props, shaderCaps)) {
         GrTextUtils::DrawDFPosText(blob, 0, fontCache, props,
-                                   skPaint, paint.getColor(), fakeGamma, viewMatrix, text,
+                                   skPaint, paint.getColor(), scalerContextFlags, viewMatrix, text,
                                    byteLength, pos, scalarsPerPosition, offset);
     } else {
         GrTextUtils::DrawBmpPosText(blob, 0, fontCache, props, skPaint,
-                                    paint.getColor(), fakeGamma, viewMatrix, text,
+                                    paint.getColor(), scalerContextFlags, viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset);
     }
     return blob;
 }
 
 void GrAtlasTextContext::drawText(GrContext* context,
                                   GrDrawContext* dc,
                                   const GrClip& clip,
                                   const GrPaint& paint, const SkPaint& skPaint,
                                   const SkMatrix& viewMatrix,
                                   const SkSurfaceProps& props,
                                   const char text[], size_t byteLength,
                                   SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
     if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix, props, *context->caps()->shaderCaps())) {
         SkAutoTUnref<GrAtlasTextBlob> blob(
             CreateDrawTextBlob(context->getTextBlobCache(), context->getBatchFontCache(),
                                *context->caps()->shaderCaps(),
                                paint, skPaint,
-                               ComputeFakeGamma(dc, paint),
+                               ComputeScalerContextFlags(dc, paint),
                                viewMatrix, props,
                                text, byteLength, x, y));
         blob->flushThrowaway(context, dc, props, fDistanceAdjustTable, skPaint, paint,
                              clip, viewMatrix, regionClipBounds, x, y);
         return;
     }
 
     // fall back to drawing as a path
     GrTextUtils::DrawTextAsPath(context, dc, clip, skPaint, viewMatrix, text, byteLength, x, y,
                                 regionClipBounds);
 }
 
 void GrAtlasTextContext::drawPosText(GrContext* context,
                                      GrDrawContext* dc,
                                      const GrClip& clip,
                                      const GrPaint& paint, const SkPaint& skPaint,
                                      const SkMatrix& viewMatrix,
                                      const SkSurfaceProps& props,
                                      const char text[], size_t byteLength,
                                      const SkScalar pos[], int scalarsPerPosition,
                                      const SkPoint& offset, const SkIRect& regionClipBounds) {
     if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix, props, *context->caps()->shaderCaps())) {
         SkAutoTUnref<GrAtlasTextBlob> blob(
             CreateDrawPosTextBlob(context->getTextBlobCache(),
                                   context->getBatchFontCache(),
                                   *context->caps()->shaderCaps(),
                                   paint, skPaint,
-                                  ComputeFakeGamma(dc, paint),
+                                  ComputeScalerContextFlags(dc, paint),
                                   viewMatrix, props,
                                   text, byteLength,
                                   pos, scalarsPerPosition,
                                   offset));
         blob->flushThrowaway(context, dc, props, fDistanceAdjustTable, skPaint, paint,
                              clip, viewMatrix, regionClipBounds, offset.fX, offset.fY);
         return;
     }
 
     // fall back to drawing as a path
@@ skipping 43 matching lines @@
     int yInt = (random->nextU() % kMaxTrans) * yPos;
     SkScalar x = SkIntToScalar(xInt);
     SkScalar y = SkIntToScalar(yInt);
 
     // right now we don't handle textblobs, nor do we handle drawPosText.  Since we only
     // intend to test the batch with this unit test, that is okay.
     SkAutoTUnref<GrAtlasTextBlob> blob(
         GrAtlasTextContext::CreateDrawTextBlob(context->getTextBlobCache(),
                                                context->getBatchFontCache(),
                                                *context->caps()->shaderCaps(), grPaint, skPaint,
-                                               GrAtlasTextContext::kTextBlobBatchFakeGamma,
+                                               GrAtlasTextContext::kTextBlobBatchScalerContextFlags,
                                                viewMatrix,
                                                gSurfaceProps, text,
                                                static_cast<size_t>(textLen), x, y));
 
     return blob->test_createBatch(textLen, 0, 0, viewMatrix, x, y, color, skPaint,
                                   gSurfaceProps, gTextContext->dfAdjustTable(),
                                   context->getBatchFontCache());
 }
 
 #endif