Move SkGpuDevice::internalDrawPath to GrBlurUtils::drawPathWithMaskFilter

src/gpu/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"
 #include "GrDrawTarget.h"
 #include "GrPath.h"
 #include "GrPathRange.h"
 #include "GrResourceProvider.h"
 #include "SkAutoKern.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkPath.h"
 #include "SkTextMapStateProc.h"
 #include "SkTextFormatParams.h"
 
 GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(GrContext* context,
-                                                           SkGpuDevice* gpuDevice,
                                                            const SkDeviceProperties& properties)
-    : GrTextContext(context, gpuDevice, properties)
+    : GrTextContext(context, properties)
     , fStroke(SkStrokeRec::kFill_InitStyle)
     , fQueuedGlyphCount(0)
     , fFallbackGlyphsIdx(kGlyphBufferSize) {
 }
 
 GrStencilAndCoverTextContext*
-GrStencilAndCoverTextContext::Create(GrContext* context, SkGpuDevice* gpuDevice,
-                                     const SkDeviceProperties& props) {
+GrStencilAndCoverTextContext::Create(GrContext* context, const SkDeviceProperties& props) {
     GrStencilAndCoverTextContext* textContext = SkNEW_ARGS(GrStencilAndCoverTextContext,
-                                                           (context, gpuDevice, props));
-    textContext->fFallbackTextContext = GrAtlasTextContext::Create(context, gpuDevice, props,
-                                                                   false);
+                                                           (context, props));
+    textContext->fFallbackTextContext = GrAtlasTextContext::Create(context, props, false);
 
     return textContext;
 }
 
 GrStencilAndCoverTextContext::~GrStencilAndCoverTextContext() {
 }
 
 bool GrStencilAndCoverTextContext::canDraw(const GrRenderTarget* rt,
                                            const GrClip& clip,
                                            const GrPaint& paint,
@@ skipping 17 matching lines @@
         && viewMatrix.hasPerspective()) {
         return false;
     }
 
     // No color bitmap fonts.
     SkScalerContext::Rec    rec;
     SkScalerContext::MakeRec(skPaint, &fDeviceProperties, NULL, &rec);
     return rec.getFormat() != SkMask::kARGB32_Format;
 }
 
-void GrStencilAndCoverTextContext::onDrawText(GrRenderTarget* rt,
+void GrStencilAndCoverTextContext::onDrawText(GrDrawContext* drawContext, GrRenderTarget* rt,
                                               const GrClip& clip,
                                               const GrPaint& paint,
                                               const SkPaint& skPaint,
                                               const SkMatrix& viewMatrix,
                                               const char text[],
                                               size_t byteLength,
                                               SkScalar x, SkScalar y,
                                               const SkIRect& regionClipBounds) {
     SkASSERT(byteLength == 0 || text != NULL);
 
@@ skipping 62 matching lines @@
     SkAutoKern autokern;
 
     SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
 
     SkFixed fx = SkScalarToFixed(x);
     SkFixed fy = SkScalarToFixed(y);
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
         fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
         if (glyph.fWidth) {
-            this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)));
+            this->appendGlyph(drawContext, glyph, 
+                              SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)));
         }
 
         fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
         fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
     }
 
-    this->finish();
+    this->finish(drawContext);
 }
 
-void GrStencilAndCoverTextContext::onDrawPosText(GrRenderTarget* rt,
+void GrStencilAndCoverTextContext::onDrawPosText(GrDrawContext* drawContext,
+                                                 GrRenderTarget* rt,
                                                  const GrClip& clip,
                                                  const GrPaint& paint,
                                                  const SkPaint& skPaint,
                                                  const SkMatrix& viewMatrix,
                                                  const char text[],
                                                  size_t byteLength,
                                                  const SkScalar pos[],
                                                  int scalarsPerPosition,
                                                  const SkPoint& offset,
                                                  const SkIRect& regionClipBounds) {
@@ skipping 23 matching lines @@
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
     SkTextAlignProc alignProc(fSkPaint.getTextAlign());
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
         if (glyph.fWidth) {
             SkPoint tmsLoc;
             tmsProc(pos, &tmsLoc);
             SkPoint loc;
             alignProc(tmsLoc, glyph, &loc);
 
-            this->appendGlyph(glyph, loc);
+            this->appendGlyph(drawContext, glyph, loc);
         }
         pos += scalarsPerPosition;
     }
 
-    this->finish();
+    this->finish(drawContext);
 }
 
 static GrPathRange* get_gr_glyphs(GrContext* ctx,
                                   const SkTypeface* typeface,
                                   const SkDescriptor* desc,
                                   const GrStrokeInfo& stroke) {
 
     static const GrUniqueKey::Domain kPathGlyphDomain = GrUniqueKey::GenerateDomain();
     int strokeDataCount = stroke.computeUniqueKeyFragmentData32Cnt();
     GrUniqueKey glyphKey;
@@ skipping 172 matching lines @@
         }
         inverse->preScale(1, -1);
     } else {
         inverse->setScale(1, -1);
         const SkMatrix& unflip = *inverse; // unflip is equal to its own inverse.
         fViewMatrix.preConcat(unflip);
     }
     return true;
 }
 
-inline void GrStencilAndCoverTextContext::appendGlyph(const SkGlyph& glyph, const SkPoint& pos) {
+inline void GrStencilAndCoverTextContext::appendGlyph(GrDrawContext* drawContext,
+                                                      const SkGlyph& glyph, const SkPoint& pos) {
     if (fQueuedGlyphCount >= fFallbackGlyphsIdx) {
         SkASSERT(fQueuedGlyphCount == fFallbackGlyphsIdx);
-        this->flush();
+        this->flush(drawContext);
     }
 
     // Stick the glyphs we can't draw at the end of the buffer, growing backwards.
     int index = (SkMask::kARGB32_Format == glyph.fMaskFormat) ?
                 --fFallbackGlyphsIdx : fQueuedGlyphCount++;
 
     fGlyphIndices[index] = glyph.getGlyphID();
     fGlyphPositions[index].set(fTextInverseRatio * pos.x(), -fTextInverseRatio * pos.y());
 }
 
 static const SkScalar* get_xy_scalar_array(const SkPoint* pointArray) {
     GR_STATIC_ASSERT(2 * sizeof(SkScalar) == sizeof(SkPoint));
     GR_STATIC_ASSERT(0 == offsetof(SkPoint, fX));
 
     return &pointArray[0].fX;
 }
 
-void GrStencilAndCoverTextContext::flush() {
+void GrStencilAndCoverTextContext::flush(GrDrawContext* drawContext) {
     if (fQueuedGlyphCount > 0) {
         SkAutoTUnref<GrPathProcessor> pp(GrPathProcessor::Create(fPaint.getColor(),
                                                                  fViewMatrix,
                                                                  fLocalMatrix));
 
-        GrDrawContext* drawContext = fContext->drawContext();
-        if (!drawContext) {
-            return;
-        }
-
         drawContext->drawPaths(&fPipelineBuilder, pp, fGlyphs,
                                fGlyphIndices, GrPathRange::kU16_PathIndexType,
                                get_xy_scalar_array(fGlyphPositions),
                                GrPathRendering::kTranslate_PathTransformType,
                                fQueuedGlyphCount, GrPathRendering::kWinding_FillType);
 
         fQueuedGlyphCount = 0;
     }
 
     if (fFallbackGlyphsIdx < kGlyphBufferSize) {
@@ skipping 16 matching lines @@
         fFallbackTextContext->drawPosText(fRenderTarget, fClip, paintFallback, skPaintFallback,
                                           fViewMatrix, (char*)&fGlyphIndices[fFallbackGlyphsIdx],
                                           2 * fallbackGlyphCount,
                                           get_xy_scalar_array(&fGlyphPositions[fFallbackGlyphsIdx]),
                                           2, SkPoint::Make(0, 0), fRegionClipBounds);
 
         fFallbackGlyphsIdx = kGlyphBufferSize;
     }
 }
 
-void GrStencilAndCoverTextContext::finish() {
-    this->flush();
+void GrStencilAndCoverTextContext::finish(GrDrawContext* drawContext) {
+    this->flush(drawContext);
 
     fGlyphs->unref();
     fGlyphs = NULL;
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fPipelineBuilder.stencil()->setDisabled();
     fStateRestore.set(NULL);
     fViewMatrix = fContextInitialMatrix;
 }