Revert of Fix SkTextBlob offset semantics. (patchset #2 id:20001 of https://codereview.chromium.org/605533002/)

Reason for revert:
Breaking the Chrome builds with the error:

[14:54:14.317833] ../../skia/ext/pixel_ref_utils.cc:221:16: error: 'drawPosText' marked 'override' but does not override any member functions
[14:54:14.318022]   virtual void drawPosText(const SkDraw& draw,
[14:54:14.318082]                ^

Original issue's description:
> Fix SkTextBlob offset semantics.
>
> Implement proper x/y drawTextBlob() handling by plumbing a
> drawPosText() offset parameter (to act as an additional glyph pos
> translation) throughout the device layer.
>
> The new offset superceeds the existing constY, with a minor semantic
> tweak: whereas previous implementations were ignoring constY in 2D
> positioning mode (scalarsPerGlyph == 2), now the offset is always
> observed, in all positioning modes. We can do this because existing
> drawPosText() clients always pass constY == 0 for full positioning mode.
>
> R=reed@google.com, jvanverth@google.com, robertphillips@google.com
>
> Committed: https://skia.googlesource.com/skia/+/c13bc571d3e61a43b87eb97f0719abd304cafaf2

R=jvanverth@google.com, reed@google.com, bsalomon@google.com, fmalita@chromium.org
TBR=bsalomon@google.com, fmalita@chromium.org, jvanverth@google.com, reed@google.com
NOTREECHECKS=true
NOTRY=true

Author: robertphillips@google.com

Review URL: https://codereview.chromium.org/609223003

1 files changed, 12 insertions, 14 deletions

diff --git a/src/core/SkTextMapStateProc.h b/src/core/SkTextMapStateProc.h
index 8ef9389b3a..5a8dcaa3b1 100644
--- a/src/core/SkTextMapStateProc.h
+++ b/src/core/SkTextMapStateProc.h
@@ -13,22 +13,20 @@
 
 class SkTextMapStateProc {
 public:
-    SkTextMapStateProc(const SkMatrix& matrix, const SkPoint& offset, int scalarsPerPosition)
+    SkTextMapStateProc(const SkMatrix& matrix, SkScalar y, int scalarsPerPosition)
         : fMatrix(matrix)
         , fProc(matrix.getMapXYProc())
-        , fOffset(offset)
-        , fScaleX(fMatrix.getScaleX()) {
+        , fY(y)
+        , fScaleX(fMatrix.getScaleX())
+        , fTransX(fMatrix.getTranslateX()) {
         SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
         if (1 == scalarsPerPosition) {
             unsigned mtype = fMatrix.getType();
             if (mtype & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)) {
                 fMapCase = kX;
             } else {
-                // Bake the matrix scale/translation components into fOffset,
-                // to expedite proc computations.
-                fOffset.set(SkScalarMul(offset.x(), fMatrix.getScaleX()) + fMatrix.getTranslateX(),
-                            SkScalarMul(offset.y(), fMatrix.getScaleY()) + fMatrix.getTranslateY());
-
+                fY = SkScalarMul(y, fMatrix.getScaleY()) +
+                    fMatrix.getTranslateY();
                 if (mtype & SkMatrix::kScale_Mask) {
                     fMapCase = kOnlyScaleX;
                 } else {
@@ -51,25 +49,25 @@ private:
         kX
     } fMapCase;
     const SkMatrix::MapXYProc fProc;
-    SkPoint  fOffset; // In kOnly* mode, this includes the matrix translation component.
-    SkScalar fScaleX; // This is only used by kOnly... cases.
+    SkScalar fY; // Ignored by kXY case.
+    SkScalar fScaleX, fTransX; // These are only used by Only... cases.
 };
 
 inline void SkTextMapStateProc::operator()(const SkScalar pos[], SkPoint* loc) const {
     switch(fMapCase) {
     case kXY:
-        fProc(fMatrix, pos[0] + fOffset.x(), pos[1] + fOffset.y(), loc);
+        fProc(fMatrix, pos[0], pos[1], loc);
         break;
     case kOnlyScaleX:
-        loc->set(SkScalarMul(fScaleX, *pos) + fOffset.x(), fOffset.y());
+        loc->set(SkScalarMul(fScaleX, *pos) + fTransX, fY);
         break;
     case kOnlyTransX:
-        loc->set(*pos + fOffset.x(), fOffset.y());
+        loc->set(*pos + fTransX, fY);
         break;
     default:
         SkASSERT(false);
     case kX:
-        fProc(fMatrix, *pos + fOffset.x(), fOffset.y(), loc);
+        fProc(fMatrix, *pos, fY, loc);
         break;
     }
 }