make internaldrawBmpText part of GrTextUtils

src/gpu/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 "GrDrawContext.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrStrokeInfo.h"
 #include "GrTextBlobCache.h"
 #include "GrTexturePriv.h"
+#include "GrTextUtils.h"
 #include "GrVertexBuffer.h"
 
 #include "SkAutoKern.h"
 #include "SkColorPriv.h"
 #include "SkColorFilter.h"
 #include "SkDistanceFieldGen.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkDrawProcs.h"
 #include "SkFindAndPlaceGlyph.h"
@@ skipping 301 matching lines @@
                                           fallbackTxt, fallbackPos, scalarsPerPosition, dfOffset);
             }
         } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
         } else {
             cacheBlob->setHasBitmap();
             SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
                                                    false);
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning:
-                    this->internalDrawBMPText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                              (const char *)it.glyphs(), textLen,
-                                              x + offset.x(), y + offset.y());
+                    GrTextUtils::DrawBmpText(cacheBlob, run, fContext->getBatchFontCache(),
+                                             cache, runPaint, color, viewMatrix,
+                                             (const char *)it.glyphs(), textLen,
+                                             x + offset.x(), y + offset.y());
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
-                    this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                                 (const char*)it.glyphs(), textLen, it.pos(), 1,
-                                                 SkPoint::Make(x, y + offset.y()));
+                    GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
+                                                cache, runPaint, color, viewMatrix,
+                                                (const char*)it.glyphs(), textLen, it.pos(), 1,
+                                                SkPoint::Make(x, y + offset.y()));
                     break;
                 case SkTextBlob::kFull_Positioning:
-                    this->internalDrawBMPPosText(cacheBlob, run, cache, runPaint, color, viewMatrix,
-                                                 (const char*)it.glyphs(), textLen, it.pos(), 2,
-                                                 SkPoint::Make(x, y));
+                    GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
+                                                cache, runPaint, color, viewMatrix,
+                                                (const char*)it.glyphs(), textLen, it.pos(), 2,
+                                                SkPoint::Make(x, y));
                     break;
             }
             SkGlyphCache::AttachCache(cache);
         }
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
     }
@@ skipping 66 matching lines @@
     SkASSERT(fallbackTxt.count());
     blob->setHasBitmap();
     Run& run = blob->fRuns[runIndex];
     // Push back a new subrun to fill and set the override descriptor
     run.push_back();
     run.fOverrideDescriptor.reset(new SkAutoDescriptor);
     skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
                                        fSurfaceProps, &viewMatrix, false);
     SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
                                                     run.fOverrideDescriptor->getDesc());
-    this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, color, viewMatrix,
-                                 fallbackTxt.begin(), fallbackTxt.count(),
-                                 fallbackPos.begin(), scalarsPerPosition, offset);
+    GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), cache, skPaint,
+                                color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
+                                fallbackPos.begin(), scalarsPerPosition, offset);
     SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkPaint* dfPaint,
                                 SkScalar* textRatio) {
     GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
 
     *dfPaint = origPaint;
@@ skipping 29 matching lines @@
                                  &offset, skPaint);
         if (fallbackTxt.count()) {
             this->fallbackDrawPosText(blob, 0, clip, paint.getColor(), skPaint, viewMatrix,
                                       fallbackTxt, fallbackPos, 2, offset);
         }
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
 
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
-        this->internalDrawBMPText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
-                                  byteLength, x, y);
+        GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
+                                 paint.getColor(), viewMatrix, text, byteLength, x, y);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 inline GrAtlasTextBlob*
 GrAtlasTextContext::createDrawPosTextBlob(const GrClip& clip,
                                           const GrPaint& paint, const SkPaint& skPaint,
                                           const SkMatrix& viewMatrix,
                                           const char text[], size_t byteLength,
@@ skipping 13 matching lines @@
                                     byteLength, pos, scalarsPerPosition, offset,
                                     textRatio, &fallbackTxt, &fallbackPos);
         if (fallbackTxt.count()) {
             this->fallbackDrawPosText(blob, 0, clip, paint.getColor(), skPaint, viewMatrix,
                                       fallbackTxt, fallbackPos, scalarsPerPosition, offset);
         }
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
         SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
-        this->internalDrawBMPPosText(blob, 0, cache, skPaint, paint.getColor(), viewMatrix, text,
-                                     byteLength, pos, scalarsPerPosition, offset);
+        GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
+                                    paint.getColor(), viewMatrix, text,
+                                    byteLength, pos, scalarsPerPosition, offset);
         SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
 
 void GrAtlasTextContext::onDrawText(GrDrawContext* dc,
                                     const GrClip& clip,
                                     const GrPaint& paint, const SkPaint& skPaint,
                                     const SkMatrix& viewMatrix,
                                     const char text[], size_t byteLength,
@@ skipping 15 matching lines @@
     SkAutoTUnref<GrAtlasTextBlob> blob(
         this->createDrawPosTextBlob(clip, paint, skPaint, viewMatrix,
                                     text, byteLength,
                                     pos, scalarsPerPosition,
                                     offset, regionClipBounds));
 
     blob->flushThrowaway(fContext, dc, fSurfaceProps, fDistanceAdjustTable, skPaint, paint, clip,
                          regionClipBounds);
 }
 
-void GrAtlasTextContext::internalDrawBMPText(GrAtlasTextBlob* blob, int runIndex,
-                                             SkGlyphCache* cache, const SkPaint& skPaint,
-                                             GrColor color,
-                                             const SkMatrix& viewMatrix,
-                                             const char text[], size_t byteLength,
-                                             SkScalar x, SkScalar y) {
-    SkASSERT(byteLength == 0 || text != nullptr);
-
-    // nothing to draw
-    if (text == nullptr || byteLength == 0) {
-        return;
-    }
-
-    fCurrStrike = nullptr;
-
-    // Get GrFontScaler from cache
-    GrFontScaler* fontScaler = GetGrFontScaler(cache);
-
-    SkFindAndPlaceGlyph::ProcessText(
-        skPaint.getTextEncoding(), text, byteLength,
-        {x, y}, viewMatrix, skPaint.getTextAlign(),
-        cache,
-        [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
-            position += rounding;
-            this->bmpAppendGlyph(
-                blob, runIndex, glyph,
-                SkScalarFloorToInt(position.fX), SkScalarFloorToInt(position.fY),
-                color, fontScaler);
-        }
-    );
-}
-
-void GrAtlasTextContext::internalDrawBMPPosText(GrAtlasTextBlob* blob, int runIndex,
-                                                SkGlyphCache* cache, const SkPaint& skPaint,
-                                                GrColor color,
-                                                const SkMatrix& viewMatrix,
-                                                const char text[], size_t byteLength,
-                                                const SkScalar pos[], int scalarsPerPosition,
-                                                const SkPoint& offset) {
-    SkASSERT(byteLength == 0 || text != nullptr);
-    SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
-
-    // nothing to draw
-    if (text == nullptr || byteLength == 0) {
-        return;
-    }
-
-    fCurrStrike = nullptr;
-
-    // Get GrFontScaler from cache
-    GrFontScaler* fontScaler = GetGrFontScaler(cache);
-
-    SkFindAndPlaceGlyph::ProcessPosText(
-        skPaint.getTextEncoding(), text, byteLength,
-        offset, viewMatrix, pos, scalarsPerPosition,
-        skPaint.getTextAlign(), cache,
-        [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
-            position += rounding;
-            this->bmpAppendGlyph(
-                blob, runIndex, glyph,
-                SkScalarFloorToInt(position.fX), SkScalarFloorToInt(position.fY),
-                color, fontScaler);
-        }
-    );
-}
-
 void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
                                             SkScalar x, SkScalar y,
                                             SkScalar textRatio,
                                             SkTDArray<char>* fallbackTxt,
                                             SkTDArray<SkScalar>* fallbackPos,
                                             SkPoint* offset,
                                             const SkPaint& origPaint) {
@@ skipping 142 matching lines @@
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 
     SkGlyphCache::AttachCache(cache);
 }
 
-void GrAtlasTextContext::bmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
-                                        const SkGlyph& skGlyph,
-                                        int vx, int vy, GrColor color, GrFontScaler* scaler) {
-    if (!fCurrStrike) {
-        fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
-    }
-
-    GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
-                                         skGlyph.getSubXFixed(),
-                                         skGlyph.getSubYFixed(),
-                                         GrGlyph::kCoverage_MaskStyle);
-    GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
-    if (!glyph) {
-        return;
-    }
-
-    int x = vx + glyph->fBounds.fLeft;
-    int y = vy + glyph->fBounds.fTop;
-
-    // keep them as ints until we've done the clip-test
-    int width = glyph->fBounds.width();
-    int height = glyph->fBounds.height();
-
-    SkRect r;
-    r.fLeft = SkIntToScalar(x);
-    r.fTop = SkIntToScalar(y);
-    r.fRight = r.fLeft + SkIntToScalar(width);
-    r.fBottom = r.fTop + SkIntToScalar(height);
-
-    blob->appendGlyph(runIndex, r, color, fCurrStrike, glyph, scaler, skGlyph,
-                      SkIntToScalar(vx), SkIntToScalar(vy), 1.0f, false);
-}
-
 bool GrAtlasTextContext::dfAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
                                        const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        SkScalar textRatio, const SkMatrix& viewMatrix) {
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
 
     GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
@@ skipping 77 matching lines @@
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return blob->createBatch(info, textLen, 0, 0, color, transX, transY, skPaint,
                              gSurfaceProps, gTextContext->dfAdjustTable(),
                              context->getBatchFontCache());
 }
 
 #endif