Rename GrBitmapTextContextB to GrAtlasTextContext

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 "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 46 matching lines @@
 }
 
 };
 
 // TODO
 // More tests
 // move to SkCache
 // handle textblobs where the whole run is larger than the cache size
 // TODO implement micro speedy hash map for fast refing of glyphs
 
-GrBitmapTextContextB::GrBitmapTextContextB(GrContext* context,
-                                         SkGpuDevice* gpuDevice,
-                                         const SkDeviceProperties& properties)
+GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
+                                       SkGpuDevice* gpuDevice,
+                                       const SkDeviceProperties& properties)
                                        : INHERITED(context, gpuDevice, properties) {
     fCurrStrike = NULL;
 }
 
-void GrBitmapTextContextB::ClearCacheEntry(uint32_t key, BitmapTextBlob** blob) {
+void GrAtlasTextContext::ClearCacheEntry(uint32_t key, BitmapTextBlob** blob) {
     (*blob)->unref();
 }
 
-GrBitmapTextContextB::~GrBitmapTextContextB() {
-    fCache.foreach(&GrBitmapTextContextB::ClearCacheEntry);
+GrAtlasTextContext::~GrAtlasTextContext() {
+    fCache.foreach(&GrAtlasTextContext::ClearCacheEntry);
 }
 
-GrBitmapTextContextB* GrBitmapTextContextB::Create(GrContext* context,
-                                                 SkGpuDevice* gpuDevice,
-                                                 const SkDeviceProperties& props) {
-    return SkNEW_ARGS(GrBitmapTextContextB, (context, gpuDevice, props));
+GrAtlasTextContext* GrAtlasTextContext::Create(GrContext* context,
+                                               SkGpuDevice* gpuDevice,
+                                               const SkDeviceProperties& props) {
+    return SkNEW_ARGS(GrAtlasTextContext, (context, gpuDevice, props));
 }
 
-bool GrBitmapTextContextB::canDraw(const GrRenderTarget*,
-                                  const GrClip&,
-                                  const GrPaint&,
-                                  const SkPaint& skPaint,
-                                  const SkMatrix& viewMatrix) {
+bool GrAtlasTextContext::canDraw(const GrRenderTarget*,
+                                 const GrClip&,
+                                 const GrPaint&,
+                                 const SkPaint& skPaint,
+                                 const SkMatrix& viewMatrix) {
     return !SkDraw::ShouldDrawTextAsPaths(skPaint, viewMatrix);
 }
 
-inline void GrBitmapTextContextB::init(GrRenderTarget* rt, const GrClip& clip,
-                                      const GrPaint& paint, const SkPaint& skPaint,
-                                      const SkIRect& regionClipBounds) {
+inline void GrAtlasTextContext::init(GrRenderTarget* rt, const GrClip& clip,
+                                     const GrPaint& paint, const SkPaint& skPaint,
+                                     const SkIRect& regionClipBounds) {
     INHERITED::init(rt, clip, paint, skPaint, regionClipBounds);
 
     fCurrStrike = NULL;
 }
 
-bool GrBitmapTextContextB::MustRegenerateBlob(const BitmapTextBlob& blob, const SkPaint& paint,
-                                             const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
+bool GrAtlasTextContext::MustRegenerateBlob(const BitmapTextBlob& blob, const SkPaint& paint,
+                                            const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
     // We always regenerate blobs with patheffects or mask filters we could cache these
     // TODO find some way to cache the maskfilter / patheffects on the textblob
     return !blob.fViewMatrix.cheapEqualTo(viewMatrix) || blob.fX != x || blob.fY != y ||
             paint.getMaskFilter() || paint.getPathEffect() || paint.getStyle() != blob.fStyle;
 }
 
 
-inline SkGlyphCache* GrBitmapTextContextB::setupCache(BitmapTextBlob::Run* run,
-                                                      const SkPaint& skPaint,
-                                                      const SkMatrix& viewMatrix) {
+inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
+                                                    const SkPaint& skPaint,
+                                                    const SkMatrix& viewMatrix) {
     skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, &viewMatrix, false);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
     return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
 }
 
-inline void GrBitmapTextContextB::BlobGlyphCount(int* glyphCount, int* runCount,
-                                                 const SkTextBlob* blob) {
+inline void GrAtlasTextContext::BlobGlyphCount(int* glyphCount, int* runCount,
+                                               const SkTextBlob* blob) {
     SkTextBlob::RunIterator itCounter(blob);
     for (; !itCounter.done(); itCounter.next(), (*runCount)++) {
         *glyphCount += itCounter.glyphCount();
     }
 }
 
-GrBitmapTextContextB::BitmapTextBlob* GrBitmapTextContextB::CreateBlob(int glyphCount,
-                                                                       int runCount) {
+GrAtlasTextContext::BitmapTextBlob* GrAtlasTextContext::CreateBlob(int glyphCount,
+                                                                   int runCount) {
     // We allocate size for the BitmapTextBlob itself, plus size for the vertices array,
     // and size for the glyphIds array.
     SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
                       vertex_attribute_changed);
     size_t verticesCount = glyphCount * kVerticesPerGlyph * kGrayTextVASize;
     size_t length = sizeof(BitmapTextBlob) +
                     verticesCount +
                     glyphCount * sizeof(GrGlyph::PackedID) +
                     sizeof(BitmapTextBlob::Run) * runCount;
 
     BitmapTextBlob* cacheBlob = SkNEW_PLACEMENT(sk_malloc_throw(length), BitmapTextBlob);
 
     // setup offsets for vertices / glyphs
     cacheBlob->fVertices = sizeof(BitmapTextBlob) + reinterpret_cast<unsigned char*>(cacheBlob);
     cacheBlob->fGlyphIDs =
             reinterpret_cast<GrGlyph::PackedID*>(cacheBlob->fVertices + verticesCount);
     cacheBlob->fRuns = reinterpret_cast<BitmapTextBlob::Run*>(cacheBlob->fGlyphIDs + glyphCount);
 
     // Initialize runs
     for (int i = 0; i < runCount; i++) {
         SkNEW_PLACEMENT(&cacheBlob->fRuns[i], BitmapTextBlob::Run);
     }
     cacheBlob->fRunCount = runCount;
     return cacheBlob;
 }
 
-void GrBitmapTextContextB::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
-                                        const SkPaint& skPaint, const SkMatrix& viewMatrix,
-                                        const SkTextBlob* blob, SkScalar x, SkScalar y,
-                                        SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
+void GrAtlasTextContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
+                                      const SkPaint& skPaint, const SkMatrix& viewMatrix,
+                                      const SkTextBlob* blob, SkScalar x, SkScalar y,
+                                      SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
     BitmapTextBlob* cacheBlob;
     BitmapTextBlob** foundBlob = fCache.find(blob->uniqueID());
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     if (foundBlob) {
         cacheBlob = *foundBlob;
         if (MustRegenerateBlob(*cacheBlob, skPaint, viewMatrix, x, y)) {
             // 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,
@@ skipping 18 matching lines @@
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     SkPaint2GrPaintShader(fContext, rt, skPaint, viewMatrix, true, &grPaint);
 
     this->flush(fContext->getTextTarget(), cacheBlob, rt, grPaint, clip, viewMatrix,
                 fSkPaint.getAlpha());
 }
 
-void GrBitmapTextContextB::regenerateTextBlob(BitmapTextBlob* cacheBlob,
-                                              const SkPaint& skPaint, const SkMatrix& viewMatrix,
-                                              const SkTextBlob* blob, SkScalar x, SkScalar y,
-                                              SkDrawFilter* drawFilter, const SkIRect& clipRect) {
+void GrAtlasTextContext::regenerateTextBlob(BitmapTextBlob* cacheBlob,
+                                            const SkPaint& skPaint, const SkMatrix& viewMatrix,
+                                            const SkTextBlob* blob, SkScalar x, SkScalar y,
+                                            SkDrawFilter* drawFilter, const SkIRect& clipRect) {
     cacheBlob->fViewMatrix = viewMatrix;
     cacheBlob->fX = x;
     cacheBlob->fY = y;
     cacheBlob->fStyle = skPaint.getStyle();
 
     // Regenerate textblob
     SkPaint runPaint = skPaint;
     SkTextBlob::RunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         int glyphCount = it.glyphCount();
@@ skipping 45 matching lines @@
 
         if (drawFilter) {
             // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
             runPaint = skPaint;
         }
 
         SkGlyphCache::AttachCache(cache);
     }
 }
 
-void GrBitmapTextContextB::onDrawText(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) {
+void GrAtlasTextContext::onDrawText(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) {
     int glyphCount = skPaint.countText(text, byteLength);
     SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
     blob->fViewMatrix = viewMatrix;
     blob->fX = x;
     blob->fY = y;
     blob->fStyle = skPaint.getStyle();
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
     this->internalDrawText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, x, y, clipRect);
     SkGlyphCache::AttachCache(cache);
 
     this->flush(fContext->getTextTarget(), blob, rt, paint, clip, viewMatrix, skPaint.getAlpha());
 }
 
-void GrBitmapTextContextB::internalDrawText(BitmapTextBlob* blob, int runIndex,
-                                            SkGlyphCache* cache, const SkPaint& skPaint,
-                                           const SkMatrix& viewMatrix,
-                                           const char text[], size_t byteLength,
-                                           SkScalar x, SkScalar y, const SkIRect& clipRect) {
+void GrAtlasTextContext::internalDrawText(BitmapTextBlob* blob, int runIndex,
+                                          SkGlyphCache* cache, const SkPaint& skPaint,
+                                          const SkMatrix& viewMatrix,
+                                          const char text[], size_t byteLength,
+                                          SkScalar x, SkScalar y, const SkIRect& clipRect) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     fCurrStrike = NULL;
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
 
@@ skipping 64 matching lines @@
                               Sk48Dot16FloorToInt(fy),
                               fontScaler,
                               clipRect);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
 }
 
-void GrBitmapTextContextB::onDrawPosText(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) {
+void GrAtlasTextContext::onDrawPosText(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) {
     int glyphCount = skPaint.countText(text, byteLength);
     SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
     blob->fStyle = skPaint.getStyle();
     blob->fViewMatrix = viewMatrix;
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
     this->internalDrawPosText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, pos,
                               scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
 
     this->flush(fContext->getTextTarget(), blob, rt, paint, clip, viewMatrix, fSkPaint.getAlpha());
 }
 
-void GrBitmapTextContextB::internalDrawPosText(BitmapTextBlob* blob, int runIndex,
-                                               SkGlyphCache* cache, const SkPaint& skPaint,
-                                              const SkMatrix& viewMatrix,
-                                              const char text[], size_t byteLength,
-                                              const SkScalar pos[], int scalarsPerPosition,
-                                              const SkPoint& offset, const SkIRect& clipRect) {
+void GrAtlasTextContext::internalDrawPosText(BitmapTextBlob* blob, int runIndex,
+                                             SkGlyphCache* cache, const SkPaint& skPaint,
+                                             const SkMatrix& viewMatrix,
+                                             const char text[], size_t byteLength,
+                                             const SkScalar pos[], int scalarsPerPosition,
+                                             const SkPoint& offset, const SkIRect& clipRect) {
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     fCurrStrike = NULL;
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
@@ skipping 132 matching lines @@
                                       Sk48Dot16FloorToInt(fy),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
 }
 
-void GrBitmapTextContextB::appendGlyph(BitmapTextBlob* blob, int runIndex, GrGlyph::PackedID packed,
-                                      int vx, int vy, GrFontScaler* scaler,
-                                      const SkIRect& clipRect) {
+void GrAtlasTextContext::appendGlyph(BitmapTextBlob* blob, int runIndex, GrGlyph::PackedID packed,
+                                     int vx, int vy, GrFontScaler* scaler,
+                                     const SkIRect& clipRect) {
     if (NULL == fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
 
     GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
     int x = vx + glyph->fBounds.fLeft;
@@ skipping 92 matching lines @@
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
     }
 
     subRun->fGlyphEndIndex++;
     subRun->fVertexEndIndex += vertexStride * kVerticesPerGlyph;
 }
 
 class BitmapTextBatch : public GrBatch {
 public:
-    typedef GrBitmapTextContextB::BitmapTextBlob Blob;
+    typedef GrAtlasTextContext::BitmapTextBlob Blob;
     typedef Blob::Run Run;
     typedef Run::SubRunInfo TextInfo;
     struct Geometry {
         Geometry() {}
         Geometry(const Geometry& geometry)
             : fBlob(SkRef(geometry.fBlob.get()))
             , fRun(geometry.fRun)
             , fSubRun(geometry.fSubRun)
             , fColor(geometry.fColor) {}
         SkAutoTUnref<Blob> fBlob;
@@ skipping 315 matching lines @@
         int fNumGlyphs;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
     GrMaskFormat fMaskFormat;
     GrPixelConfig fPixelConfig;
     GrBatchFontCache* fFontCache;
 };
 
-void GrBitmapTextContextB::flush(GrDrawTarget* target, BitmapTextBlob* blob, GrRenderTarget* rt,
-                                 const GrPaint& paint, const GrClip& clip,
-                                 const SkMatrix& viewMatrix, int paintAlpha) {
+void GrAtlasTextContext::flush(GrDrawTarget* target, BitmapTextBlob* blob, GrRenderTarget* rt,
+                               const GrPaint& paint, const GrClip& clip,
+                               const SkMatrix& viewMatrix, int paintAlpha) {
     GrPipelineBuilder pipelineBuilder;
     pipelineBuilder.setFromPaint(paint, rt, clip);
 
     GrColor color = paint.getColor();
     for (uint32_t run = 0; run < blob->fRunCount; run++) {
         for (int subRun = 0; subRun < blob->fRuns[run].fSubRunInfo.count(); subRun++) {
             PerSubRunInfo& info = blob->fRuns[run].fSubRunInfo[subRun];
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
             if (0 == glyphCount) {
                 continue;
@@ skipping 20 matching lines @@
     for (int i = 0; i < blob->fBigGlyphs.count(); i++) {
         BitmapTextBlob::BigGlyph& bigGlyph = blob->fBigGlyphs[i];
         SkMatrix translate;
         translate.setTranslate(SkIntToScalar(bigGlyph.fVx), SkIntToScalar(bigGlyph.fVy));
         SkPath tmpPath(bigGlyph.fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(rt, clip, paint, SkMatrix::I(), tmpPath, strokeInfo);
     }
 }