Fix SkTextBlob offset semantics.

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 "GrDrawTarget.h"
 #include "GrGpu.h"
@@ skipping 36 matching lines @@
     // too. This in turn has the side-effect that NVPR can not stroke the paths,
     // as the stroke in NVPR is defined in object-space.
     // NOTE: here we have following coincidence that works at the moment:
     // - When using the device-space glyphs, the transforms we pass to NVPR
     // instanced drawing are the global transforms, and the view transform is
     // identity. NVPR can not use non-affine transforms in the instanced
     // drawing. This is taken care of by SkDraw::ShouldDrawTextAsPaths since it
     // will turn off the use of device-space glyphs when perspective transforms
     // are in use.
 
-    this->init(paint, skPaint, byteLength, kMaxAccuracy_RenderMode);
+    this->init(paint, skPaint, byteLength, kMaxAccuracy_RenderMode, SkPoint::Make(0, 0));
 
     // Transform our starting point.
     if (fNeedsDeviceSpaceGlyphs) {
         SkPoint loc;
         fContextInitialMatrix.mapXY(x, y, &loc);
         x = loc.fX;
         y = loc.fY;
     }
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
@@ skipping 48 matching lines @@
     }
 
     this->finish();
 }
 
 void GrStencilAndCoverTextContext::drawPosText(const GrPaint& paint,
                                                const SkPaint& skPaint,
                                                const char text[],
                                                size_t byteLength,
                                                const SkScalar pos[],
-                                               SkScalar constY,
-                                               int scalarsPerPosition) {
+                                               int scalarsPerPosition,
+                                               const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
         return;
     }
 
     // This is the fast path.  Here we do not bake in the device-transform to
     // the glyph outline or the advances. This is because we do not need to
     // position the glyphs at all, since the caller has done the positioning.
     // The positioning is based on SkPaint::measureText of individual
     // glyphs. That already uses glyph cache without device transforms. Device
     // transform is not part of SkPaint::measureText API, and thus we use the
     // same glyphs as what were measured.
 
-    const float textTranslateY = (1 == scalarsPerPosition ? constY : 0);
-    this->init(paint, skPaint, byteLength, kMaxPerformance_RenderMode, textTranslateY);
+    this->init(paint, skPaint, byteLength, kMaxPerformance_RenderMode, offset);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     const char* stop = text + byteLength;
 
     if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
         if (1 == scalarsPerPosition) {
             fTransformType = GrPathRendering::kTranslateX_PathTransformType;
             while (text < stop) {
                 const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
                 if (glyph.fWidth) {
                     this->appendGlyph(glyph.getGlyphID(), *pos);
                 }
                 pos++;
             }
         } else {
             SkASSERT(2 == scalarsPerPosition);
             fTransformType = GrPathRendering::kTranslate_PathTransformType;
             while (text < stop) {
                 const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
                 if (glyph.fWidth) {
                     this->appendGlyph(glyph.getGlyphID(), pos[0], pos[1]);
                 }
                 pos += 2;
             }
         }
     } else {
         fTransformType = GrPathRendering::kTranslate_PathTransformType;
-        SkTextMapStateProc tmsProc(SkMatrix::I(), 0, scalarsPerPosition);
+        SkTextMapStateProc tmsProc(SkMatrix::I(), SkPoint::Make(0, 0), scalarsPerPosition);
         SkTextAlignProcScalar 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.getGlyphID(), loc.x(), loc.y());
@@ skipping 50 matching lines @@
         ctx->addResourceToCache(resourceKey, glyphs);
     }
 
     return glyphs.detach();
 }
 
 void GrStencilAndCoverTextContext::init(const GrPaint& paint,
                                         const SkPaint& skPaint,
                                         size_t textByteLength,
                                         RenderMode renderMode,
-                                        SkScalar textTranslateY) {
+                                        const SkPoint& textTranslate) {
     GrTextContext::init(paint, skPaint);
 
     fContextInitialMatrix = fContext->getMatrix();
 
     const bool otherBackendsWillDrawAsPaths =
         SkDraw::ShouldDrawTextAsPaths(skPaint, fContextInitialMatrix);
 
     fNeedsDeviceSpaceGlyphs = !otherBackendsWillDrawAsPaths &&
                               kMaxAccuracy_RenderMode == renderMode &&
                               SkToBool(fContextInitialMatrix.getType() &
                                        (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask));
 
     if (fNeedsDeviceSpaceGlyphs) {
         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
         SkASSERT(!fContextInitialMatrix.hasPerspective());
-        SkASSERT(0 == textTranslateY); // TODO: Handle textTranslateY in device-space usecase.
+        SkASSERT(textTranslate.isZero()); // TODO: Handle textTranslate in device-space usecase.
 
         fTextRatio = fTextInverseRatio = 1.0f;
 
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         SkMatrix m;
         m.setScale(1, -1);
         fContext->setMatrix(m);
 
         // Post-flip the initial matrix so we're left with just the flip after
         // the paint preConcats the inverse.
@@ skipping 61 matching lines @@
             canUseRawPaths = SK_Scalar1 == fSkPaint.getTextScaleX() &&
                              0 == fSkPaint.getTextSkewX() &&
                              !fSkPaint.isFakeBoldText() &&
                              !fSkPaint.isVerticalText();
         } else {
             fTextRatio = fTextInverseRatio = 1.0f;
             canUseRawPaths = false;
         }
 
         SkMatrix textMatrix;
-        textMatrix.setTranslate(0, textTranslateY);
+        textMatrix.setTranslate(textTranslate.x(), textTranslate.y());
         // Glyphs loaded by GPU path rendering have an inverted y-direction.
         textMatrix.preScale(fTextRatio, -fTextRatio);
         fPaint.localCoordChange(textMatrix);
         fContext->concatMatrix(textMatrix);
 
         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, NULL, false);
         fGlyphs = canUseRawPaths ?
                       get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, gpuStroke) :
                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
                                     &fGlyphCache->getDescriptor(), gpuStroke);
@@ skipping 63 matching lines @@
 
     SkGlyphCache::AttachCache(fGlyphCache);
     fGlyphCache = NULL;
 
     fDrawTarget->drawState()->stencil()->setDisabled();
     fStateRestore.set(NULL);
     fContext->setMatrix(fContextInitialMatrix);
     GrTextContext::finish();
 }