Move more internal methods from GrContext to GrContextPriv (take 3)

Change-Id: Ied630e61cf95780bf85032867e6ce663e1ef9c2f
Reviewed-on: https://skia-review.googlesource.com/98000
Reviewed-by: Greg Daniel <egdaniel@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

5 files changed, 72 insertions, 57 deletions

diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index ca671b4500..9e9f58a4d6 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -347,7 +347,7 @@ static void calculate_translation(bool applyVM,
     }
 }
 
-void GrAtlasTextBlob::flushBigGlyphs(GrContext* context, GrTextUtils::Target* target,
+void GrAtlasTextBlob::flushBigGlyphs(GrTextUtils::Target* target,
                                      const GrClip& clip, const SkPaint& paint,
                                      const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
                                      const SkIRect& clipBounds) {
@@ -366,11 +366,11 @@ void GrAtlasTextBlob::flushBigGlyphs(GrContext* context, GrTextUtils::Target* ta
     }
 }
 
-void GrAtlasTextBlob::flushBigRun(GrContext* context, GrTextUtils::Target* target,
-                                    const SkSurfaceProps& props, const SkTextBlobRunIterator& it,
-                                    const GrClip& clip, const GrTextUtils::Paint& paint,
-                                    SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
-                                    const SkIRect& clipBounds, SkScalar x, SkScalar y) {
+void GrAtlasTextBlob::flushBigRun(GrTextUtils::Target* target,
+                                  const SkSurfaceProps& props, const SkTextBlobRunIterator& it,
+                                  const GrClip& clip, const GrTextUtils::Paint& paint,
+                                  SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
+                                  const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
     const SkPoint& offset = it.offset();
 
@@ -381,24 +381,24 @@ void GrAtlasTextBlob::flushBigRun(GrContext* context, GrTextUtils::Target* targe
 
     switch (it.positioning()) {
         case SkTextBlob::kDefault_Positioning:
-            GrTextUtils::DrawBigText(context, target, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawBigText(target, clip, runPaint, viewMatrix,
                                      (const char*)it.glyphs(), textLen, x + offset.x(),
                                      y + offset.y(), clipBounds);
             break;
         case SkTextBlob::kHorizontal_Positioning:
-            GrTextUtils::DrawBigPosText(context, target, props, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawBigPosText(target, props, clip, runPaint, viewMatrix,
                                         (const char*)it.glyphs(), textLen, it.pos(), 1,
                                         SkPoint::Make(x, y + offset.y()), clipBounds);
             break;
         case SkTextBlob::kFull_Positioning:
-            GrTextUtils::DrawBigPosText(context, target, props, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawBigPosText(target, props, clip, runPaint, viewMatrix,
                                         (const char*)it.glyphs(), textLen, it.pos(), 2,
                                         SkPoint::Make(x, y), clipBounds);
             break;
     }
 }
 
-void GrAtlasTextBlob::flushCached(GrContext* context, GrTextUtils::Target* target,
+void GrAtlasTextBlob::flushCached(GrAtlasGlyphCache* atlasGlyphCache, GrTextUtils::Target* target,
                                   const SkTextBlob* blob, const SkSurfaceProps& props,
                                   const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                   const GrTextUtils::Paint& paint, SkDrawFilter* drawFilter,
@@ -409,19 +409,20 @@ void GrAtlasTextBlob::flushCached(GrContext* context, GrTextUtils::Target* targe
     SkTextBlobRunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         if (fRuns[run].fTooBigForAtlas) {
-            this->flushBigRun(context, target, props, it, clip, paint, drawFilter, viewMatrix,
+            this->flushBigRun(target, props, it, clip, paint, drawFilter, viewMatrix,
                               clipBounds, x, y);
             continue;
         }
         this->flushRun(target, clip, run, viewMatrix, x, y, paint, props, distanceAdjustTable,
-                       context->getAtlasGlyphCache());
+                       atlasGlyphCache);
     }
 
     // Now flush big glyphs
-    this->flushBigGlyphs(context, target, clip, paint, viewMatrix, x, y, clipBounds);
+    this->flushBigGlyphs(target, clip, paint, viewMatrix, x, y, clipBounds);
 }
 
-void GrAtlasTextBlob::flushThrowaway(GrContext* context, GrTextUtils::Target* target,
+void GrAtlasTextBlob::flushThrowaway(GrAtlasGlyphCache* atlasGlyphCache,
+                                     GrTextUtils::Target* target,
                                      const SkSurfaceProps& props,
                                      const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                      const GrTextUtils::Paint& paint, const GrClip& clip,
@@ -429,11 +430,11 @@ void GrAtlasTextBlob::flushThrowaway(GrContext* context, GrTextUtils::Target* ta
                                      SkScalar x, SkScalar y) {
     for (int run = 0; run < fRunCount; run++) {
         this->flushRun(target, clip, run, viewMatrix, x, y, paint, props, distanceAdjustTable,
-                       context->getAtlasGlyphCache());
+                       atlasGlyphCache);
     }
 
     // Now flush big glyphs
-    this->flushBigGlyphs(context, target, clip, paint, viewMatrix, x, y, clipBounds);
+    this->flushBigGlyphs(target, clip, paint, viewMatrix, x, y, clipBounds);
 }
 
 std::unique_ptr<GrDrawOp> GrAtlasTextBlob::test_makeOp(
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h
index 7106f11bf8..11cb059602 100644
--- a/src/gpu/text/GrAtlasTextBlob.h
+++ b/src/gpu/text/GrAtlasTextBlob.h
@@ -194,14 +194,14 @@ public:
                         const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
 
     // flush a GrAtlasTextBlob associated with a SkTextBlob
-    void flushCached(GrContext* context, GrTextUtils::Target*, const SkTextBlob* blob,
+    void flushCached(GrAtlasGlyphCache*, GrTextUtils::Target*, const SkTextBlob* blob,
                      const SkSurfaceProps& props,
                      const GrDistanceFieldAdjustTable* distanceAdjustTable,
                      const GrTextUtils::Paint&, SkDrawFilter* drawFilter, const GrClip& clip,
                      const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x, SkScalar y);
 
     // flush a throwaway GrAtlasTextBlob *not* associated with an SkTextBlob
-    void flushThrowaway(GrContext* context, GrTextUtils::Target*, const SkSurfaceProps& props,
+    void flushThrowaway(GrAtlasGlyphCache*, GrTextUtils::Target*, const SkSurfaceProps& props,
                         const GrDistanceFieldAdjustTable* distanceAdjustTable,
                         const GrTextUtils::Paint& paint, const GrClip& clip,
                         const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
@@ -294,11 +294,11 @@ private:
                          const GrDistanceFieldAdjustTable* distanceAdjustTable,
                          GrAtlasGlyphCache* cache);
 
-    void flushBigGlyphs(GrContext* context, GrTextUtils::Target*, const GrClip& clip,
+    void flushBigGlyphs(GrTextUtils::Target*, const GrClip& clip,
                         const SkPaint& paint, const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
                         const SkIRect& clipBounds);
 
-    void flushBigRun(GrContext* context, GrTextUtils::Target*, const SkSurfaceProps& props,
+    void flushBigRun(GrTextUtils::Target*, const SkSurfaceProps& props,
                      const SkTextBlobRunIterator& it, const GrClip& clip,
                      const GrTextUtils::Paint& paint, SkDrawFilter* drawFilter,
                      const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index 3578154fcc..946bf1371a 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -6,6 +6,7 @@
  */
 #include "GrAtlasTextContext.h"
 #include "GrContext.h"
+#include "GrContextPriv.h"
 #include "GrTextBlobCache.h"
 #include "SkDistanceFieldGen.h"
 #include "SkDraw.h"
@@ -121,7 +122,9 @@ void GrAtlasTextContext::drawTextBlob(GrContext* context, GrTextUtils::Target* t
                       drawFilter);
     uint32_t scalerContextFlags = ComputeScalerContextFlags(target->colorSpaceInfo());
 
-    GrTextBlobCache* cache = context->getTextBlobCache();
+    auto atlasGlyphCache = context->contextPriv().getAtlasGlyphCache();
+    GrTextBlobCache* textBlobCache = context->contextPriv().getTextBlobCache();
+
     if (canCache) {
         bool hasLCD = HasLCD(blob);
 
@@ -141,7 +144,7 @@ void GrAtlasTextContext::drawTextBlob(GrContext* context, GrTextUtils::Target* t
         key.fHasBlur = SkToBool(mf);
         key.fCanonicalColor = canonicalColor;
         key.fScalerContextFlags = scalerContextFlags;
-        cacheBlob = cache->find(key);
+        cacheBlob = textBlobCache->find(key);
     }
 
     GrTextUtils::Paint paint(&skPaint, &target->colorSpaceInfo());
@@ -150,21 +153,21 @@ void GrAtlasTextContext::drawTextBlob(GrContext* context, GrTextUtils::Target* t
             // 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.get());
-            cacheBlob = cache->makeCachedBlob(blob, key, blurRec, skPaint);
-            this->regenerateTextBlob(cacheBlob.get(), context->getAtlasGlyphCache(),
+            textBlobCache->remove(cacheBlob.get());
+            cacheBlob = textBlobCache->makeCachedBlob(blob, key, blurRec, skPaint);
+            this->regenerateTextBlob(cacheBlob.get(), atlasGlyphCache,
                                      *context->caps()->shaderCaps(), paint, scalerContextFlags,
                                      viewMatrix, props, blob, x, y, drawFilter);
         } else {
-            cache->makeMRU(cacheBlob.get());
+            textBlobCache->makeMRU(cacheBlob.get());
 
             if (CACHE_SANITY_CHECK) {
                 int glyphCount = 0;
                 int runCount = 0;
                 GrTextBlobCache::BlobGlyphCount(&glyphCount, &runCount, blob);
-                sk_sp<GrAtlasTextBlob> sanityBlob(cache->makeBlob(glyphCount, runCount));
+                sk_sp<GrAtlasTextBlob> sanityBlob(textBlobCache->makeBlob(glyphCount, runCount));
                 sanityBlob->setupKey(key, blurRec, skPaint);
-                this->regenerateTextBlob(sanityBlob.get(), context->getAtlasGlyphCache(),
+                this->regenerateTextBlob(sanityBlob.get(), atlasGlyphCache,
                                          *context->caps()->shaderCaps(), paint, scalerContextFlags,
                                          viewMatrix, props, blob, x, y, drawFilter);
                 GrAtlasTextBlob::AssertEqual(*sanityBlob, *cacheBlob);
@@ -172,16 +175,16 @@ void GrAtlasTextContext::drawTextBlob(GrContext* context, GrTextUtils::Target* t
         }
     } else {
         if (canCache) {
-            cacheBlob = cache->makeCachedBlob(blob, key, blurRec, skPaint);
+            cacheBlob = textBlobCache->makeCachedBlob(blob, key, blurRec, skPaint);
         } else {
-            cacheBlob = cache->makeBlob(blob);
+            cacheBlob = textBlobCache->makeBlob(blob);
         }
-        this->regenerateTextBlob(cacheBlob.get(), context->getAtlasGlyphCache(),
+        this->regenerateTextBlob(cacheBlob.get(), atlasGlyphCache,
                                  *context->caps()->shaderCaps(), paint, scalerContextFlags,
                                  viewMatrix, props, blob, x, y, drawFilter);
     }
 
-    cacheBlob->flushCached(context, target, blob, props, fDistanceAdjustTable.get(), paint,
+    cacheBlob->flushCached(atlasGlyphCache, target, blob, props, fDistanceAdjustTable.get(), paint,
                            drawFilter, clip, viewMatrix, clipBounds, x, y);
 }
 
@@ -318,23 +321,27 @@ void GrAtlasTextContext::drawText(GrContext* context, GrTextUtils::Target* targe
     if (context->abandoned()) {
         return;
     }
+
+    auto atlasGlyphCache = context->contextPriv().getAtlasGlyphCache();
+    auto textBlobCache = context->contextPriv().getTextBlobCache();
+
     GrTextUtils::Paint paint(&skPaint, &target->colorSpaceInfo());
-    if (this->canDraw(context->getAtlasGlyphCache(), skPaint, viewMatrix, props,
+    if (this->canDraw(atlasGlyphCache, skPaint, viewMatrix, props,
                       *context->caps()->shaderCaps())) {
         sk_sp<GrAtlasTextBlob> blob(
-                this->makeDrawTextBlob(context->getTextBlobCache(), context->getAtlasGlyphCache(),
+                this->makeDrawTextBlob(textBlobCache, atlasGlyphCache,
                                        *context->caps()->shaderCaps(), paint,
                                        ComputeScalerContextFlags(target->colorSpaceInfo()),
                                        viewMatrix, props, text, byteLength, x, y));
         if (blob) {
-            blob->flushThrowaway(context, target, props, fDistanceAdjustTable.get(), paint, clip,
-                                 viewMatrix, regionClipBounds, x, y);
+            blob->flushThrowaway(atlasGlyphCache, target, props, fDistanceAdjustTable.get(), paint,
+                                 clip, viewMatrix, regionClipBounds, x, y);
         }
         return;
     }
 
     // fall back to drawing as a path or scaled glyph
-    GrTextUtils::DrawBigText(context, target, clip, paint, viewMatrix, text, byteLength, x, y,
+    GrTextUtils::DrawBigText(target, clip, paint, viewMatrix, text, byteLength, x, y,
                              regionClipBounds);
 }
 
@@ -347,22 +354,27 @@ void GrAtlasTextContext::drawPosText(GrContext* context, GrTextUtils::Target* ta
     GrTextUtils::Paint paint(&skPaint, &target->colorSpaceInfo());
     if (context->abandoned()) {
         return;
-    } else if (this->canDraw(context->getAtlasGlyphCache(), skPaint, viewMatrix, props,
-                             *context->caps()->shaderCaps())) {
+    }
+
+    auto atlasGlyphCache = context->contextPriv().getAtlasGlyphCache();
+    auto textBlobCache = context->contextPriv().getTextBlobCache();
+
+    if (this->canDraw(atlasGlyphCache, skPaint, viewMatrix, props,
+                      *context->caps()->shaderCaps())) {
         sk_sp<GrAtlasTextBlob> blob(this->makeDrawPosTextBlob(
-                context->getTextBlobCache(), context->getAtlasGlyphCache(),
+                textBlobCache, atlasGlyphCache,
                 *context->caps()->shaderCaps(), paint,
                 ComputeScalerContextFlags(target->colorSpaceInfo()), viewMatrix, props, text,
                 byteLength, pos, scalarsPerPosition, offset));
         if (blob) {
-            blob->flushThrowaway(context, target, props, fDistanceAdjustTable.get(), paint, clip,
-                                 viewMatrix, regionClipBounds, offset.fX, offset.fY);
+            blob->flushThrowaway(atlasGlyphCache, target, props, fDistanceAdjustTable.get(), paint,
+                                 clip, viewMatrix, regionClipBounds, offset.fX, offset.fY);
         }
         return;
     }
 
     // fall back to drawing as a path or scaled glyph
-    GrTextUtils::DrawBigPosText(context, target, props, clip, paint, viewMatrix, text,
+    GrTextUtils::DrawBigPosText(target, props, clip, paint, viewMatrix, text,
                                 byteLength, pos, scalarsPerPosition, offset, regionClipBounds);
 }
 
@@ -835,16 +847,18 @@ GR_DRAW_OP_TEST_DEFINE(GrAtlasTextOp) {
     SkScalar x = SkIntToScalar(xInt);
     SkScalar y = SkIntToScalar(yInt);
 
+    auto atlasGlyphCache = context->contextPriv().getAtlasGlyphCache();
+
     // right now we don't handle textblobs, nor do we handle drawPosText. Since we only intend to
     // test the text op with this unit test, that is okay.
     sk_sp<GrAtlasTextBlob> blob(gTextContext->makeDrawTextBlob(
-            context->getTextBlobCache(), context->getAtlasGlyphCache(),
+            context->contextPriv().getTextBlobCache(), atlasGlyphCache,
             *context->caps()->shaderCaps(), utilsPaint,
             GrAtlasTextContext::kTextBlobOpScalerContextFlags, viewMatrix, gSurfaceProps, text,
             static_cast<size_t>(textLen), x, y));
 
     return blob->test_makeOp(textLen, 0, 0, viewMatrix, x, y, utilsPaint, gSurfaceProps,
-                             gTextContext->dfAdjustTable(), context->getAtlasGlyphCache(),
+                             gTextContext->dfAdjustTable(), atlasGlyphCache,
                              rtc->textTarget());
 }
 
diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp
index 47585f7fcf..d354619a43 100644
--- a/src/gpu/text/GrTextUtils.cpp
+++ b/src/gpu/text/GrTextUtils.cpp
@@ -78,7 +78,7 @@ bool GrTextUtils::ShouldDisableLCD(const SkPaint& paint) {
            paint.isFakeBoldText() || paint.getStyle() != SkPaint::kFill_Style;
 }
 
-void GrTextUtils::DrawBigText(GrContext* context, GrTextUtils::Target* target,
+void GrTextUtils::DrawBigText(GrTextUtils::Target* target,
                               const GrClip& clip, const SkPaint& paint,
                               const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                               SkScalar x, SkScalar y, const SkIRect& clipBounds) {
@@ -104,7 +104,7 @@ void GrTextUtils::DrawBigText(GrContext* context, GrTextUtils::Target* target,
     }
 }
 
-void GrTextUtils::DrawBigPosText(GrContext* context, GrTextUtils::Target* target,
+void GrTextUtils::DrawBigPosText(GrTextUtils::Target* target,
                                  const SkSurfaceProps& props, const GrClip& clip,
                                  const SkPaint& origPaint, const SkMatrix& viewMatrix,
                                  const char text[], size_t byteLength, const SkScalar pos[],
diff --git a/src/gpu/text/GrTextUtils.h b/src/gpu/text/GrTextUtils.h
index 3b1968decd..252cd7c626 100644
--- a/src/gpu/text/GrTextUtils.h
+++ b/src/gpu/text/GrTextUtils.h
@@ -129,17 +129,17 @@ public:
     static bool ShouldDisableLCD(const SkPaint& paint);
 
     // Functions for drawing large text either as paths or (for color emoji) as scaled glyphs
-    static void DrawBigText(GrContext*, GrTextUtils::Target*, const GrClip& clip,
-                               const SkPaint& paint, const SkMatrix& viewMatrix, const char text[],
-                               size_t byteLength, SkScalar x, SkScalar y,
+    static void DrawBigText(GrTextUtils::Target*, const GrClip& clip,
+                            const SkPaint& paint, const SkMatrix& viewMatrix, const char text[],
+                            size_t byteLength, SkScalar x, SkScalar y,
+                            const SkIRect& clipBounds);
+
+    static void DrawBigPosText(GrTextUtils::Target*,
+                               const SkSurfaceProps& props, const GrClip& clip,
+                               const SkPaint& paint, const SkMatrix& viewMatrix,
+                               const char text[], size_t byteLength, const SkScalar pos[],
+                               int scalarsPerPosition, const SkPoint& offset,
                                const SkIRect& clipBounds);
-
-    static void DrawBigPosText(GrContext* context, GrTextUtils::Target*,
-                                  const SkSurfaceProps& props, const GrClip& clip,
-                                  const SkPaint& paint, const SkMatrix& viewMatrix,
-                                  const char text[], size_t byteLength, const SkScalar pos[],
-                                  int scalarsPerPosition, const SkPoint& offset,
-                                  const SkIRect& clipBounds);
 };
 
 #endif