Revert of Fast path translate() in SkCanvas and SkLiteDL.

src/core/SkLiteDL.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageFilter.h"
@@ skipping 34 matching lines @@
 
 // Pre-cache lazy non-threadsafe fields on SkPath and/or SkMatrix.
 static void make_threadsafe(SkPath* path, SkMatrix* matrix) {
     if (path)   { path->updateBoundsCache(); }
     if (matrix) { (void)matrix->getType(); }
 }
 
 namespace {
 #define TYPES(M)                                                                \
     M(Save) M(Restore) M(SaveLayer)                                             \
-    M(Concat) M(SetMatrix) M(Translate) M(TranslateZ)                           \
+    M(Concat) M(SetMatrix) M(TranslateZ)                                        \
     M(ClipPath) M(ClipRect) M(ClipRRect) M(ClipRegion)                          \
     M(DrawPaint) M(DrawPath) M(DrawRect) M(DrawOval) M(DrawRRect) M(DrawDRRect) \
     M(DrawAnnotation) M(DrawDrawable) M(DrawPicture) M(DrawShadowedPicture)     \
     M(DrawImage) M(DrawImageNine) M(DrawImageRect) M(DrawImageLattice)          \
     M(DrawText) M(DrawPosText) M(DrawPosTextH)                                  \
     M(DrawTextOnPath) M(DrawTextRSXform) M(DrawTextBlob)                        \
     M(DrawPatch) M(DrawPoints) M(DrawVertices) M(DrawAtlas)
 
 #define M(T) T,
     enum class Type : uint8_t { TYPES(M) };
@@ skipping 42 matching lines @@
     };
     struct SetMatrix final : Op {
         static const auto kType = Type::SetMatrix;
         SetMatrix(const SkMatrix& matrix) : matrix(matrix) {}
         SkMatrix matrix;
         void draw(SkCanvas* c, const SkMatrix& original) {
             c->setMatrix(SkMatrix::Concat(original, matrix));
         }
         void makeThreadsafe() { make_threadsafe(nullptr, &matrix); }
     };
-    struct Translate final : Op {
-        static const auto kType = Type::Translate;
-        Translate(SkScalar dx, SkScalar dy) : dx(dx), dy(dy) {}
-        SkScalar dx,dy;
-        void draw(SkCanvas* c, const SkMatrix&) {
-            c->translate(dx, dy);
-        }
-    };
     struct TranslateZ final : Op {
         static const auto kType = Type::TranslateZ;
         TranslateZ(SkScalar dz) : dz(dz) {}
         SkScalar dz;
         void draw(SkCanvas* c, const SkMatrix&) {
         #ifdef SK_EXPERIMENTAL_SHADOWING
             c->translateZ(dz);
         #endif
         }
     };
@@ skipping 404 matching lines @@
     }
 }
 
 void SkLiteDL::   save() { this->push   <Save>(0); }
 void SkLiteDL::restore() { this->push<Restore>(0); }
 void SkLiteDL::saveLayer(const SkRect* bounds, const SkPaint* paint,
                          const SkImageFilter* backdrop, SkCanvas::SaveLayerFlags flags) {
     this->push<SaveLayer>(0, bounds, paint, backdrop, flags);
 }
 
-void SkLiteDL::   concat(const SkMatrix& matrix)   { this->push   <Concat>(0, matrix); }
-void SkLiteDL::setMatrix(const SkMatrix& matrix)   { this->push<SetMatrix>(0, matrix); }
-void SkLiteDL::translate(SkScalar dx, SkScalar dy) { this->push<Translate>(0, dx, dy); }
+void SkLiteDL::   concat(const SkMatrix& matrix) { this->push   <Concat>(0, matrix); }
+void SkLiteDL::setMatrix(const SkMatrix& matrix) { this->push<SetMatrix>(0, matrix); }
 void SkLiteDL::translateZ(SkScalar dz) { this->push<TranslateZ>(0, dz); }
 
 void SkLiteDL::clipPath(const SkPath& path, SkRegion::Op op, bool aa) {
     this->push<ClipPath>(0, path, op, aa);
 }
 void SkLiteDL::clipRect(const SkRect& rect, SkRegion::Op op, bool aa) {
     this->push<ClipRect>(0, rect, op, aa);
 }
 void SkLiteDL::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool aa) {
     this->push<ClipRRect>(0, rrect, op, aa);
@@ skipping 190 matching lines @@
 }
 
 void SkLiteDL::reset(SkRect bounds) {
     SkASSERT(this->unique());
     this->map(dtor_fns);
 
     // Leave fBytes and fReserved alone.
     fUsed   = 0;
     fBounds = bounds;
 }