Create GrTextUtils

src/gpu/GrAtlasTextBlob.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 "GrAtlasTextBlob.h"
 
 #include "GrBlurUtils.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
+#include "GrTextUtils.h"
 #include "SkColorFilter.h"
 #include "SkDrawFilter.h"
 #include "SkTextBlobRunIterator.h"
 #include "batches/GrAtlasTextBatch.h"
 
 void GrAtlasTextBlob::appendGlyph(int runIndex,
                                   const SkRect& positions,
                                   GrColor color,
                                   GrBatchTextStrike* strike,
                                   GrGlyph* glyph,
@@ skipping 270 matching lines @@
         ctm.postTranslate(bigGlyph.fVx, bigGlyph.fVy);
         if (bigGlyph.fApplyVM) {
             ctm.postConcat(fViewMatrix);
         }
 
         GrBlurUtils::drawPathWithMaskFilter(context, dc, clip, bigGlyph.fPath,
                                             skPaint, ctm, nullptr, clipBounds, false);
     }
 }
 
-void GrAtlasTextBlob::flushRunAsPaths(GrDrawContext* dc,
-                                      GrTextContext* textContext,
+void GrAtlasTextBlob::flushRunAsPaths(GrContext* context, GrDrawContext* dc,
                                       const SkSurfaceProps& props,
                                       const SkTextBlobRunIterator& it,
                                       const GrClip& clip, const SkPaint& skPaint,
                                       SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                                       const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     SkPaint runPaint = skPaint;
 
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
     const SkPoint& offset = it.offset();
 
     it.applyFontToPaint(&runPaint);
 
     if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
         return;
     }
 
     runPaint.setFlags(GrTextContext::FilterTextFlags(props, runPaint));
 
     switch (it.positioning()) {
         case SkTextBlob::kDefault_Positioning:
-            textContext->drawTextAsPath(dc, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawTextAsPath(context, dc, clip, runPaint, viewMatrix,
                                         (const char *)it.glyphs(),
                                         textLen, x + offset.x(), y + offset.y(), clipBounds);
             break;
         case SkTextBlob::kHorizontal_Positioning:
-            textContext->drawPosTextAsPath(dc, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawPosTextAsPath(context, dc, props, clip, runPaint, viewMatrix,
                                            (const char*)it.glyphs(),
                                            textLen, it.pos(), 1, SkPoint::Make(x, y + offset.y()),
                                            clipBounds);
             break;
         case SkTextBlob::kFull_Positioning:
-            textContext->drawPosTextAsPath(dc, clip, runPaint, viewMatrix,
+            GrTextUtils::DrawPosTextAsPath(context, dc, props, clip, runPaint, viewMatrix,
                                            (const char*)it.glyphs(),
                                            textLen, it.pos(), 2, SkPoint::Make(x, y), clipBounds);
             break;
     }
 }
 
-void GrAtlasTextBlob::flushCached(const SkTextBlob* blob,
-                                  GrContext* context,
+void GrAtlasTextBlob::flushCached(GrContext* context,
                                   GrDrawContext* dc,
-                                  GrTextContext* textContext,
+                                  const SkTextBlob* blob,
                                   const SkSurfaceProps& props,
                                   const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                   const SkPaint& skPaint,
                                   const GrPaint& grPaint,
                                   SkDrawFilter* drawFilter,
                                   const GrClip& clip,
                                   const SkMatrix& viewMatrix,
                                   const SkIRect& clipBounds,
                                   SkScalar x, SkScalar y,
                                   SkScalar transX, SkScalar transY) {
     // We loop through the runs of the blob, flushing each.  If any run is too large, then we flush
     // it as paths
     GrPipelineBuilder pipelineBuilder(grPaint, dc->accessRenderTarget(), clip);
 
     GrColor color = grPaint.getColor();
 
     SkTextBlobRunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         if (fRuns[run].fDrawAsPaths) {
-            this->flushRunAsPaths(dc, textContext, props, it, clip, skPaint,
+            this->flushRunAsPaths(context, dc, props, it, clip, skPaint,
                                   drawFilter, viewMatrix, clipBounds, x, y);
             continue;
         }
         fRuns[run].fVertexBounds.offset(transX, transY);
         this->flushRun(dc, &pipelineBuilder, run, color,
                        transX, transY, skPaint, props,
                        distanceAdjustTable, context->getBatchFontCache());
     }
 
     // Now flush big glyphs
@@ skipping 115 matching lines @@
                      rSubRun.fBulkUseToken.fPlotAlreadyUpdated);
             for (int k = 0; k < lSubRun.fBulkUseToken.fPlotsToUpdate.count(); k++) {
                 SkASSERT(lSubRun.fBulkUseToken.fPlotsToUpdate[k] ==
                          rSubRun.fBulkUseToken.fPlotsToUpdate[k]);
             }*/
         }
     }
 }
 
 #endif