SkLiteDL: thread the original canvas matrix through for SetMatrix::Draw().

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 74 matching lines @@
         int optimizeFor(GrContext*) { sk_throw(); return 0;}
         int makeThreadsafe()        { sk_throw(); return 0;}
 
         uint32_t type :  8;
         uint32_t skip : 24;
     };
     static_assert(sizeof(Op) == 4, "");
 
     struct Save final : Op {
         static const auto kType = Type::Save;
-        void draw(SkCanvas* c) { c->save(); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->save(); }
     };
     struct Restore final : Op {
         static const auto kType = Type::Restore;
-        void draw(SkCanvas* c) { c->restore(); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->restore(); }
     };
     struct SaveLayer final : Op {
         static const auto kType = Type::SaveLayer;
         SaveLayer(const SkRect* bounds, const SkPaint* paint,
                   const SkImageFilter* backdrop, SkCanvas::SaveLayerFlags flags) {
             if (bounds) { this->bounds = *bounds; }
             if (paint)  { this->paint  = *paint;  }
             this->backdrop = sk_ref_sp(backdrop);
             this->flags = flags;
         }
         SkRect                     bounds = kUnset;
         SkPaint                    paint;
         sk_sp<const SkImageFilter> backdrop;
         SkCanvas::SaveLayerFlags   flags;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->saveLayer({ maybe_unset(bounds), &paint, backdrop.get(), flags });
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
 
     struct Concat final : Op {
         static const auto kType = Type::Concat;
         Concat(const SkMatrix& matrix) : matrix(matrix) {}
         SkMatrix matrix;
-        void draw(SkCanvas* c) { c->concat(matrix); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->concat(matrix); }
         void makeThreadsafe() { make_threadsafe(nullptr, &matrix); }
     };
     struct SetMatrix final : Op {
         static const auto kType = Type::SetMatrix;
         SetMatrix(const SkMatrix& matrix) : matrix(matrix) {}
         SkMatrix matrix;
-        void draw(SkCanvas* c) { c->setMatrix(matrix); }
+        void draw(SkCanvas* c, const SkMatrix& original) {

[reed1, 2016/08/16 23:31:50]

Crazy idea (to avoid having to pass 2 params to everyone)

- store a matrix* when you record SetMatrix, pointing to a single matrix shared
by all ops
- on playback, just jam the original in there, so SetMatrix::draw becomes

void draw(SkCanvas* c) { c->concat(SkMatrix::Concat(*original, matrix); }

+            c->setMatrix(SkMatrix::Concat(original, matrix));
+        }
         void makeThreadsafe() { make_threadsafe(nullptr, &matrix); }
     };
     struct TranslateZ final : Op {
         static const auto kType = Type::TranslateZ;
         TranslateZ(SkScalar dz) : dz(dz) {}
         SkScalar dz;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
         #ifdef SK_EXPERIMENTAL_SHADOWING
             c->translateZ(dz);
         #endif
         }
     };
 
     struct ClipPath final : Op {
         static const auto kType = Type::ClipPath;
         ClipPath(const SkPath& path, SkRegion::Op op, bool aa) : path(path), op(op), aa(aa) {}
         SkPath       path;
         SkRegion::Op op;
         bool         aa;
-        void draw(SkCanvas* c) { c->clipPath(path, op, aa); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->clipPath(path, op, aa); }
         void makeThreadsafe() { make_threadsafe(&path, nullptr); }
     };
     struct ClipRect final : Op {
         static const auto kType = Type::ClipRect;
         ClipRect(const SkRect& rect, SkRegion::Op op, bool aa) : rect(rect), op(op), aa(aa) {}
         SkRect       rect;
         SkRegion::Op op;
         bool         aa;
-        void draw(SkCanvas* c) { c->clipRect(rect, op, aa); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->clipRect(rect, op, aa); }
     };
     struct ClipRRect final : Op {
         static const auto kType = Type::ClipRRect;
         ClipRRect(const SkRRect& rrect, SkRegion::Op op, bool aa) : rrect(rrect), op(op), aa(aa) {}
         SkRRect      rrect;
         SkRegion::Op op;
         bool         aa;
-        void draw(SkCanvas* c) { c->clipRRect(rrect, op, aa); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->clipRRect(rrect, op, aa); }
     };
     struct ClipRegion final : Op {
         static const auto kType = Type::ClipRegion;
         ClipRegion(const SkRegion& region, SkRegion::Op op) : region(region), op(op) {}
         SkRegion     region;
         SkRegion::Op op;
-        void draw(SkCanvas* c) { c->clipRegion(region, op); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->clipRegion(region, op); }
     };
 
     struct DrawPaint final : Op {
         static const auto kType = Type::DrawPaint;
         DrawPaint(const SkPaint& paint) : paint(paint) {}
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawPaint(paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawPaint(paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawPath final : Op {
         static const auto kType = Type::DrawPath;
         DrawPath(const SkPath& path, const SkPaint& paint) : path(path), paint(paint) {}
         SkPath  path;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawPath(path, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawPath(path, paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
         void makeThreadsafe() { make_threadsafe(&path, nullptr); }
     };
     struct DrawRect final : Op {
         static const auto kType = Type::DrawRect;
         DrawRect(const SkRect& rect, const SkPaint& paint) : rect(rect), paint(paint) {}
         SkRect  rect;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawRect(rect, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawRect(rect, paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawOval final : Op {
         static const auto kType = Type::DrawOval;
         DrawOval(const SkRect& oval, const SkPaint& paint) : oval(oval), paint(paint) {}
         SkRect  oval;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawOval(oval, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawOval(oval, paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawRRect final : Op {
         static const auto kType = Type::DrawRRect;
         DrawRRect(const SkRRect& rrect, const SkPaint& paint) : rrect(rrect), paint(paint) {}
         SkRRect rrect;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawRRect(rrect, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawRRect(rrect, paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawDRRect final : Op {
         static const auto kType = Type::DrawDRRect;
         DrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint)
             : outer(outer), inner(inner), paint(paint) {}
         SkRRect outer, inner;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawDRRect(outer, inner, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawDRRect(outer, inner, paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
 
     struct DrawAnnotation final : Op {
         static const auto kType = Type::DrawAnnotation;
         DrawAnnotation(const SkRect& rect, SkData* value) : rect(rect), value(sk_ref_sp(value)) {}
         SkRect        rect;
         sk_sp<SkData> value;
-        void draw(SkCanvas* c) { c->drawAnnotation(rect, pod<char>(this), value.get()); }
+        void draw(SkCanvas* c, const SkMatrix&) {
+            c->drawAnnotation(rect, pod<char>(this), value.get());
+        }
     };
     struct DrawDrawable final : Op {
         static const auto kType = Type::DrawDrawable;
         DrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) : drawable(sk_ref_sp(drawable)) {
             if (matrix) { this->matrix = *matrix; }
         }
         sk_sp<SkDrawable>      drawable;
         sk_sp<const SkPicture> snapped;
         SkMatrix               matrix = SkMatrix::I();
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             snapped ? c->drawPicture(snapped.get(), &matrix, nullptr)
                     : c->drawDrawable(drawable.get(), &matrix);
         }
         void makeThreadsafe() {
             snapped.reset(drawable->newPictureSnapshot());
             make_threadsafe(nullptr, &matrix);
         }
     };
     struct DrawPicture final : Op {
         static const auto kType = Type::DrawPicture;
         DrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint)
             : picture(sk_ref_sp(picture)) {
             if (matrix) { this->matrix = *matrix; }
             if (paint)  { this->paint  = *paint; has_paint = true; }
         }
         sk_sp<const SkPicture> picture;
         SkMatrix               matrix = SkMatrix::I();
         SkPaint                paint;
         bool                   has_paint = false;  // TODO: why is a default paint not the same?
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->drawPicture(picture.get(), &matrix, has_paint ? &paint : nullptr);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
         void makeThreadsafe() { make_threadsafe(nullptr, &matrix); }
     };
     struct DrawShadowedPicture final : Op {
         static const auto kType = Type::DrawShadowedPicture;
         DrawShadowedPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint)
             : picture(sk_ref_sp(picture)) {
             if (matrix) { this->matrix = *matrix; }
             if (paint)  { this->paint  = *paint;  }
         }
         sk_sp<const SkPicture> picture;
         SkMatrix               matrix = SkMatrix::I();
         SkPaint                paint;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
         #ifdef SK_EXPERIMENTAL_SHADOWING
             c->drawShadowedPicture(picture.get(), &matrix, &paint);
         #endif
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
         void makeThreadsafe() { make_threadsafe(nullptr, &matrix); }
     };
 
     struct DrawImage final : Op {
         static const auto kType = Type::DrawImage;
         DrawImage(sk_sp<const SkImage>&& image, SkScalar x, SkScalar y, const SkPaint* paint)
             : image(std::move(image)), x(x), y(y) {
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
         SkScalar x,y;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawImage(image.get(), x,y, &paint); }
+        void draw(SkCanvas* c, const SkMatrix&) { c->drawImage(image.get(), x,y, &paint); }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint, &image); }
     };
     struct DrawImageNine final : Op {
         static const auto kType = Type::DrawImageNine;
         DrawImageNine(sk_sp<const SkImage>&& image,
                       const SkIRect& center, const SkRect& dst, const SkPaint* paint)
             : image(std::move(image)), center(center), dst(dst) {
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
         SkIRect center;
         SkRect  dst;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawImageNine(image.get(), center, dst, &paint); }
+        void draw(SkCanvas* c, const SkMatrix&) {
+            c->drawImageNine(image.get(), center, dst, &paint);
+        }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint, &image); }
     };
     struct DrawImageRect final : Op {
         static const auto kType = Type::DrawImageRect;
         DrawImageRect(sk_sp<const SkImage>&& image, const SkRect* src, const SkRect& dst,
                       const SkPaint* paint, SkCanvas::SrcRectConstraint constraint)
             : image(std::move(image)), dst(dst), constraint(constraint) {
             this->src = src ? *src : SkRect::MakeIWH(image->width(), image->height());
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
         SkRect src, dst;
         SkPaint paint;
         SkCanvas::SrcRectConstraint constraint;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->drawImageRect(image.get(), src, dst, &paint, constraint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint, &image); }
     };
     struct DrawImageLattice final : Op {
         static const auto kType = Type::DrawImageLattice;
         DrawImageLattice(sk_sp<const SkImage>&& image, int xs, int ys,
                          const SkRect& dst, const SkPaint* paint)
             : image(std::move(image)), xs(xs), ys(ys), dst(dst) {
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
         int                  xs, ys;
         SkRect               dst;
         SkPaint              paint;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             auto xdivs = pod<int>(this, 0),
                  ydivs = pod<int>(this, xs*sizeof(int));
             c->drawImageLattice(image.get(), {xdivs, xs, ydivs, ys}, dst, &paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint, &image); }
     };
 
     struct DrawText final : Op {
         static const auto kType = Type::DrawText;
         DrawText(size_t bytes, SkScalar x, SkScalar y, const SkPaint& paint)
             : bytes(bytes), x(x), y(y), paint(paint) {}
         size_t bytes;
         SkScalar x,y;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawText(pod<void>(this), bytes, x,y, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) {
+            c->drawText(pod<void>(this), bytes, x,y, paint);
+        }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawPosText final : Op {
         static const auto kType = Type::DrawPosText;
         DrawPosText(size_t bytes, const SkPaint& paint, int n)
             : bytes(bytes), paint(paint), n(n) {}
         size_t bytes;
         SkPaint paint;
         int n;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             auto points = pod<SkPoint>(this);
             auto text   = pod<void>(this, n*sizeof(SkPoint));
             c->drawPosText(text, bytes, points, paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawPosTextH final : Op {
         static const auto kType = Type::DrawPosTextH;
         DrawPosTextH(size_t bytes, SkScalar y, const SkPaint& paint, int n)
             : bytes(bytes), y(y), paint(paint), n(n) {}
         size_t   bytes;
         SkScalar y;
         SkPaint  paint;
         int n;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             auto xs   = pod<SkScalar>(this);
             auto text = pod<void>(this, n*sizeof(SkScalar));
             c->drawPosTextH(text, bytes, xs, y, paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawTextOnPath final : Op {
         static const auto kType = Type::DrawTextOnPath;
         DrawTextOnPath(size_t bytes, const SkPath& path,
                        const SkMatrix* matrix, const SkPaint& paint)
             : bytes(bytes), path(path), paint(paint) {
             if (matrix) { this->matrix = *matrix; }
         }
         size_t   bytes;
         SkPath   path;
         SkMatrix matrix = SkMatrix::I();
         SkPaint  paint;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->drawTextOnPath(pod<void>(this), bytes, path, &matrix, paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
         void makeThreadsafe() { make_threadsafe(&path, &matrix); }
     };
     struct DrawTextRSXform final : Op {
         static const auto kType = Type::DrawTextRSXform;
         DrawTextRSXform(size_t bytes, const SkRect* cull, const SkPaint& paint)
             : bytes(bytes), paint(paint) {
             if (cull) { this->cull = *cull; }
         }
         size_t  bytes;
         SkRect  cull = kUnset;
         SkPaint paint;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->drawTextRSXform(pod<void>(this), bytes, pod<SkRSXform>(this, bytes),
                                maybe_unset(cull), paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawTextBlob final : Op {
         static const auto kType = Type::DrawTextBlob;
         DrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint)
             : blob(sk_ref_sp(blob)), x(x), y(y), paint(paint) {}
         sk_sp<const SkTextBlob> blob;
         SkScalar x,y;
         SkPaint paint;
-        void draw(SkCanvas* c) { c->drawTextBlob(blob.get(), x,y, paint); }
+        void draw(SkCanvas* c, const SkMatrix&) {
+            c->drawTextBlob(blob.get(), x,y, paint);
+        }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
 
     struct DrawPatch final : Op {
         static const auto kType = Type::DrawPatch;
         DrawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texs[4],
                   SkXfermode* xfermode, const SkPaint& paint)
             : xfermode(sk_ref_sp(xfermode)), paint(paint) {
             copy_v(this->cubics, cubics, 12);
             if (colors) { copy_v(this->colors, colors, 4); has_colors = true; }
             if (texs  ) { copy_v(this->texs  , texs  , 4); has_texs   = true; }
         }
         SkPoint           cubics[12];
         SkColor           colors[4];
         SkPoint           texs[4];
         sk_sp<SkXfermode> xfermode;
         SkPaint           paint;
         bool              has_colors = false;
         bool              has_texs   = false;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             c->drawPatch(cubics, has_colors ? colors : nullptr, has_texs ? texs : nullptr,
                          xfermode.get(), paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawPoints final : Op {
         static const auto kType = Type::DrawPoints;
         DrawPoints(SkCanvas::PointMode mode, size_t count, const SkPaint& paint)
             : mode(mode), count(count), paint(paint) {}
         SkCanvas::PointMode mode;
         size_t              count;
         SkPaint             paint;
-        void draw(SkCanvas* c) { c->drawPoints(mode, count, pod<SkPoint>(this), paint); }
+        void draw(SkCanvas* c, const SkMatrix&) {
+            c->drawPoints(mode, count, pod<SkPoint>(this), paint);
+        }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint); }
     };
     struct DrawVertices final : Op {
         static const auto kType = Type::DrawVertices;
         DrawVertices(SkCanvas::VertexMode mode, int count, SkXfermode* xfermode, int nindices,
                      const SkPaint& paint, bool has_texs, bool has_colors, bool has_indices)
             : mode(mode), count(count), xfermode(sk_ref_sp(xfermode)), nindices(nindices)
             , paint(paint), has_texs(has_texs), has_colors(has_colors), has_indices(has_indices) {}
         SkCanvas::VertexMode mode;
         int                  count;
         sk_sp<SkXfermode>    xfermode;
         int                  nindices;
         SkPaint              paint;
         bool                 has_texs;
         bool                 has_colors;
         bool                 has_indices;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             SkPoint* vertices = pod<SkPoint>(this, 0);
             size_t offset = count*sizeof(SkPoint);
 
             SkPoint* texs = nullptr;
             if (has_texs) {
                 texs = pod<SkPoint>(this, offset);
                 offset += count*sizeof(SkPoint);
             }
 
             SkColor* colors = nullptr;
@@ skipping 18 matching lines @@
             : atlas(sk_ref_sp(atlas)), count(count), xfermode(xfermode), has_colors(has_colors) {
             if (cull)  { this->cull  = *cull; }
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> atlas;
         int                  count;
         SkXfermode::Mode     xfermode;
         SkRect               cull = kUnset;
         SkPaint              paint;
         bool                 has_colors;
-        void draw(SkCanvas* c) {
+        void draw(SkCanvas* c, const SkMatrix&) {
             auto xforms = pod<SkRSXform>(this, 0);
             auto   texs = pod<SkRect>(this, count*sizeof(SkRSXform));
             auto colors = has_colors
                 ? pod<SkColor>(this, count*(sizeof(SkRSXform) + sizeof(SkRect)))
                 : nullptr;
             c->drawAtlas(atlas.get(), xforms, texs, colors, count, xfermode,
                          maybe_unset(cull), &paint);
         }
         void optimizeFor(GrContext* ctx) { optimize_for(ctx, &paint, &atlas); }
     };
@@ skipping 11 matching lines @@
     }
     SkASSERT(fUsed + skip <= fReserved);
     auto op = (T*)(fBytes.get() + fUsed);
     fUsed += skip;
     new (op) T{ std::forward<Args>(args)... };
     op->type = (uint32_t)T::kType;
     op->skip = skip;
     return op+1;
 }
 
-template <typename... Args>
-inline void SkLiteDL::map(void (*const fns[])(void*, Args...), Args... args) {
+template <typename Fn, typename... Args>
+inline void SkLiteDL::map(const Fn fns[], Args... args) {
     auto end = fBytes.get() + fUsed;
     for (uint8_t* ptr = fBytes.get(); ptr < end; ) {
         auto op = (Op*)ptr;
         auto type = op->type;
         auto skip = op->skip;
         if (auto fn = fns[type]) {  // We replace no-op functions with nullptrs
             fn(op, args...);        // to avoid the overhead of a pointless call.
         }
         ptr += skip;
     }
@@ skipping 162 matching lines @@
     if (colors) {
         bytes += count*sizeof(SkColor);
     }
     void* pod = this->push<DrawAtlas>(bytes,
                                       atlas, count, xfermode, cull, paint, colors != nullptr);
     copy_v(pod, xforms, count,
                   texs, count,
                 colors, colors ? count : 0);
 }
 
-typedef void(* skcanvas_fn)(void*,  SkCanvas*);
+typedef void(*     draw_fn)(void*,  SkCanvas*, const SkMatrix&);
 typedef void(*grcontext_fn)(void*, GrContext*);
 typedef void(*     void_fn)(void*);
 
 // All ops implement draw().
-#define M(T) [](void* op, SkCanvas* c) { ((T*)op)->draw(c); },
-static const skcanvas_fn draw_fns[] = { TYPES(M) };
+#define M(T) [](void* op, SkCanvas* c, const SkMatrix& original) { ((T*)op)->draw(c, original); },
+static const draw_fn draw_fns[] = { TYPES(M) };
 #undef M
 
 // Ops that implement optimizeFor() or makeThreadsafe() return void from those functions;
 // the (throwing) defaults return int.
 #define M(T) std::is_void<decltype(((T*)nullptr)->optimizeFor(nullptr))>::value \
     ? [](void* op, GrContext* ctx) { ((T*)op)->optimizeFor(ctx); } : (grcontext_fn)nullptr,
 static const grcontext_fn optimize_for_fns[] = { TYPES(M) };
 #undef M
 
 #define M(T) std::is_void<decltype(((T*)nullptr)->makeThreadsafe())>::value \
     ? [](void* op) { ((T*)op)->makeThreadsafe(); } : (void_fn)nullptr,
 static const void_fn make_threadsafe_fns[] = { TYPES(M) };
 #undef M
 
 // Older libstdc++ has pre-standard std::has_trivial_destructor.
 #if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000)
     template <typename T> using can_skip_destructor = std::has_trivial_destructor<T>;
 #else
     template <typename T> using can_skip_destructor = std::is_trivially_destructible<T>;
 #endif
 
 // Most state ops (matrix, clip, save, restore) have a trivial destructor.
 #define M(T) !can_skip_destructor<T>::value ? [](void* op) { ((T*)op)->~T(); } : (void_fn)nullptr,
 static const void_fn dtor_fns[] = { TYPES(M) };
 #undef M
 
-void SkLiteDL::onDraw        (SkCanvas* canvas) { this->map(draw_fns, canvas); }
-void SkLiteDL::optimizeFor   (GrContext* ctx)   { this->map(optimize_for_fns, ctx); }
-void SkLiteDL::makeThreadsafe()                 { this->map(make_threadsafe_fns); }
+void SkLiteDL::onDraw(SkCanvas* canvas) {
+    SkMatrix original = canvas->getTotalMatrix();
+    this->map(draw_fns, canvas, original);
+}
+void SkLiteDL::optimizeFor   (GrContext* ctx) { this->map(optimize_for_fns, ctx); }
+void SkLiteDL::makeThreadsafe()               { this->map(make_threadsafe_fns); }
 
 SkRect SkLiteDL::onGetBounds() {
     return fBounds;
 }
 
 bool SkLiteDL::empty() const {
     return fUsed == 0;
 }
 
 SkLiteDL:: SkLiteDL(SkRect bounds) : fUsed(0), fReserved(0), fBounds(bounds) {}
 
 SkLiteDL::~SkLiteDL() {
     this->reset(SkRect::MakeEmpty());
 }
 
 sk_sp<SkLiteDL> SkLiteDL::New(SkRect bounds) {
     return sk_sp<SkLiteDL>(new SkLiteDL(bounds));
 }
 
 void SkLiteDL::reset(SkRect bounds) {
     SkASSERT(this->unique());
     this->map(dtor_fns);
 
     // Leave fBytes and fReserved alone.
     fUsed   = 0;
     fBounds = bounds;
 }