Remove GrContext* from GrTextContext

src/gpu/text/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrAtlasTextContext.h"
 #include "GrDrawContext.h"
@@ skipping 19 matching lines @@
 template<typename Key, typename Val> static void delete_hash_map_entry(const Key&, Val* val) {
     SkASSERT(*val);
     delete *val;
 }
 
 template<typename T> static void delete_hash_table_entry(T* val) {
     SkASSERT(*val);
     delete *val;
 }
 
-GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(GrContext* context)
-    : INHERITED(context)
-    , fFallbackTextContext(nullptr)
+GrStencilAndCoverTextContext::GrStencilAndCoverTextContext()
+    : fFallbackTextContext(nullptr)
     , fCacheSize(0) {
 }
 
 GrStencilAndCoverTextContext*
-GrStencilAndCoverTextContext::Create(GrContext* context) {
-    GrStencilAndCoverTextContext* textContext = 
-        new GrStencilAndCoverTextContext(context);
-    textContext->fFallbackTextContext = GrAtlasTextContext::Create(context);
+GrStencilAndCoverTextContext::Create() {
+    GrStencilAndCoverTextContext* textContext = new GrStencilAndCoverTextContext();
+    textContext->fFallbackTextContext = GrAtlasTextContext::Create();
 
     return textContext;
 }
 
 GrStencilAndCoverTextContext::~GrStencilAndCoverTextContext() {
     delete fFallbackTextContext;
     fBlobIdCache.foreach(delete_hash_map_entry<uint32_t, TextBlob*>);
     fBlobKeyCache.foreach(delete_hash_table_entry<TextBlob*>);
 }
 
 bool GrStencilAndCoverTextContext::internalCanDraw(const SkPaint& skPaint) {
     if (skPaint.getRasterizer()) {
         return false;
     }
     if (skPaint.getMaskFilter()) {
         return false;
     }
     if (SkPathEffect* pe = skPaint.getPathEffect()) {
         if (pe->asADash(nullptr) != SkPathEffect::kDash_DashType) {
             return false;
         }
     }
     // No hairlines. They would require new paths with customized strokes for every new draw matrix.
     return SkPaint::kStroke_Style != skPaint.getStyle() || 0 != skPaint.getStrokeWidth();
 }
 
-void GrStencilAndCoverTextContext::drawText(GrDrawContext* dc,
+void GrStencilAndCoverTextContext::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& clipBounds) {
-    if (fContext->abandoned()) {
+    if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix)) {
         TextRun run(skPaint);
         GrPipelineBuilder pipelineBuilder(paint, dc->accessRenderTarget(), clip);
         run.setText(text, byteLength, x, y);
-        run.draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props, 0, 0,
+        run.draw(context, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props, 0, 0,
                  clipBounds, fFallbackTextContext, skPaint);
         return;
-    } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props)) {
-        fFallbackTextContext->drawText(dc, clip, paint, skPaint, viewMatrix, props, text,
+    } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props,
+                                             *context->caps()->shaderCaps())) {
+        fFallbackTextContext->drawText(context, dc, clip, paint, skPaint, viewMatrix, props, text,
                                        byteLength, x, y, clipBounds);
         return;
     }
 
     // fall back to drawing as a path
-    GrTextUtils::DrawTextAsPath(fContext, dc, clip, skPaint, viewMatrix, text, byteLength, x, y,
+    GrTextUtils::DrawTextAsPath(context, dc, clip, skPaint, viewMatrix, text, byteLength, x, y,
                                 clipBounds);
 }
 
-void GrStencilAndCoverTextContext::drawPosText(GrDrawContext* dc,
+void GrStencilAndCoverTextContext::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& clipBounds) {
-    if (fContext->abandoned()) {
+    if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix)) {
         TextRun run(skPaint);
         GrPipelineBuilder pipelineBuilder(paint, dc->accessRenderTarget(), clip);
         run.setPosText(text, byteLength, pos, scalarsPerPosition, offset);
-        run.draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props, 0, 0,
+        run.draw(context, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props, 0, 0,
                  clipBounds, fFallbackTextContext, skPaint);
         return;
-    } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props)) {
-        fFallbackTextContext->drawPosText(dc, clip, paint, skPaint, viewMatrix, props,
+    } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props,
+                                             *context->caps()->shaderCaps())) {
+        fFallbackTextContext->drawPosText(context, dc, clip, paint, skPaint, viewMatrix, props,
                                           text, byteLength, pos,
                                           scalarsPerPosition, offset, clipBounds);
         return;
     }
 
     // fall back to drawing as a path
-    GrTextUtils::DrawPosTextAsPath(fContext, dc, props, clip, skPaint, viewMatrix, text,
+    GrTextUtils::DrawPosTextAsPath(context, dc, props, clip, skPaint, viewMatrix, text,
                                    byteLength, pos, scalarsPerPosition, offset, clipBounds);
 }
 
-void GrStencilAndCoverTextContext::uncachedDrawTextBlob(GrDrawContext* dc,
+void GrStencilAndCoverTextContext::uncachedDrawTextBlob(GrContext* context,
+                                                        GrDrawContext* dc,
                                                         const GrClip& clip, const SkPaint& skPaint,
                                                         const SkMatrix& viewMatrix,
                                                         const SkSurfaceProps& props,
                                                         const SkTextBlob* blob,
                                                         SkScalar x, SkScalar y,
                                                         SkDrawFilter* drawFilter,
                                                         const SkIRect& clipBounds) {
     SkPaint runPaint = skPaint;
 
     SkTextBlobRunIterator it(blob);
     for (;!it.done(); it.next()) {
         size_t textLen = it.glyphCount() * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
 
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint for this reason.
         it.applyFontToPaint(&runPaint);
 
         if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
             // A false return from filter() means we should abort the current draw.
             runPaint = skPaint;
             continue;
         }
 
         runPaint.setFlags(FilterTextFlags(props, runPaint));
 
         GrPaint grPaint;
-        if (!SkPaintToGrPaint(fContext, runPaint, viewMatrix, &grPaint)) {
+        if (!SkPaintToGrPaint(context, runPaint, viewMatrix, &grPaint)) {
             return;
         }
 
         switch (it.positioning()) {
             case SkTextBlob::kDefault_Positioning:
-                this->drawText(dc, clip, grPaint, runPaint, viewMatrix, props,
+                this->drawText(context, dc, clip, grPaint, runPaint, viewMatrix, props,
                                (const char *)it.glyphs(),
                                textLen, x + offset.x(), y + offset.y(), clipBounds);
                 break;
             case SkTextBlob::kHorizontal_Positioning:
-                this->drawPosText(dc, clip, grPaint, runPaint, viewMatrix, props,
+                this->drawPosText(context, dc, clip, grPaint, runPaint, viewMatrix, props,
                                   (const char*)it.glyphs(),
                                   textLen, it.pos(), 1, SkPoint::Make(x, y + offset.y()),
                                   clipBounds);
                 break;
             case SkTextBlob::kFull_Positioning:
-                this->drawPosText(dc, clip, grPaint, runPaint, viewMatrix, props,
+                this->drawPosText(context, dc, clip, grPaint, runPaint, viewMatrix, props,
                                   (const char*)it.glyphs(),
                                   textLen, it.pos(), 2, SkPoint::Make(x, y), clipBounds);
                 break;
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
     }
 }
 
-void GrStencilAndCoverTextContext::drawTextBlob(GrDrawContext* dc,
+void GrStencilAndCoverTextContext::drawTextBlob(GrContext* context, GrDrawContext* dc,
                                                 const GrClip& clip, const SkPaint& skPaint,
                                                 const SkMatrix& viewMatrix,
                                                 const SkSurfaceProps& props,
                                                 const SkTextBlob* skBlob, SkScalar x, SkScalar y,
                                                 SkDrawFilter* drawFilter,
                                                 const SkIRect& clipBounds) {
-    if (fContext->abandoned()) {
+    if (context->abandoned()) {
         return;
     }
 
     if (!this->internalCanDraw(skPaint)) {
-        fFallbackTextContext->drawTextBlob(dc, clip, skPaint, viewMatrix, props, skBlob, x, y,
-                                           drawFilter, clipBounds);
+        fFallbackTextContext->drawTextBlob(context, dc, clip, skPaint, viewMatrix, props, skBlob,
+                                           x, y, drawFilter, clipBounds);
         return;
     }
 
     if (drawFilter || skPaint.getPathEffect()) {
         // This draw can't be cached.
-        this->uncachedDrawTextBlob(dc, clip, skPaint, viewMatrix, props, skBlob, x, y, drawFilter,
-                                   clipBounds);
+        this->uncachedDrawTextBlob(context, dc, clip, skPaint, viewMatrix, props, skBlob, x, y,
+                                   drawFilter, clipBounds);
         return;
     }
 
     GrPaint paint;
-    if (!SkPaintToGrPaint(fContext, skPaint, viewMatrix, &paint)) {
+    if (!SkPaintToGrPaint(context, skPaint, viewMatrix, &paint)) {
         return;
     }
 
     const TextBlob& blob = this->findOrCreateTextBlob(skBlob, skPaint);
     GrPipelineBuilder pipelineBuilder(paint, dc->accessRenderTarget(), clip);
 
     TextBlob::Iter iter(blob);
     for (TextRun* run = iter.get(); run; run = iter.next()) {
-        run->draw(fContext, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props,  x, y,
+        run->draw(context, dc, &pipelineBuilder, paint.getColor(), viewMatrix, props,  x, y,
                   clipBounds, fFallbackTextContext, skPaint);
         run->releaseGlyphCache();
     }
 }
 
 const GrStencilAndCoverTextContext::TextBlob&
 GrStencilAndCoverTextContext::findOrCreateTextBlob(const SkTextBlob* skBlob,
                                                    const SkPaint& skPaint) {
     // The font-related parameters are baked into the text blob and will override this skPaint, so
     // the only remaining properties that can affect a TextBlob are the ones related to stroke.
@@ skipping 374 matching lines @@
         dc->drawPathBatch(*pipelineBuilder, batch);
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStroke.applyToPaint(&fallbackSkPaint);
         if (!fStroke.isFillStyle()) {
             fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
         }
 
-        fallbackTextContext->drawTextBlob(dc, pipelineBuilder->clip(), fallbackSkPaint, viewMatrix,
-                                          props, fFallbackTextBlob, x, y, nullptr, clipBounds);
+        fallbackTextContext->drawTextBlob(ctx, dc, pipelineBuilder->clip(), fallbackSkPaint,
+                                          viewMatrix, props, fFallbackTextBlob, x, y, nullptr,
+                                          clipBounds);
     }
 }
 
 SkGlyphCache* GrStencilAndCoverTextContext::TextRun::getGlyphCache() const {
     if (!fDetachedGlyphCache) {
         fDetachedGlyphCache = fFont.detachCache(nullptr, nullptr, true /*ignoreGamma*/);
     }
     return fDetachedGlyphCache;
 }
 
@@ skipping 60 matching lines @@
 }
 
 const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfNeeded(int *count) {
     *count = fCount;
     if (fCount) {
         this->flush();
         return fBuilder->build();
     }
     return nullptr;
 }