Add a src rect to drawImageLattice() API

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 "SkDrawFilter.h"
@@ skipping 335 matching lines @@
         SkRect src, dst;
         SkPaint paint;
         SkCanvas::SrcRectConstraint constraint;
         void draw(SkCanvas* c, const SkMatrix&) {
             c->drawImageRect(image.get(), src, dst, &paint, constraint);
         }
     };
     struct DrawImageLattice final : Op {
         static const auto kType = Type::DrawImageLattice;
         DrawImageLattice(sk_sp<const SkImage>&& image, int xs, int ys, int fs,
-                         const SkRect& dst, const SkPaint* paint)
-            : image(std::move(image)), xs(xs), ys(ys), fs(fs), dst(dst) {
+                         const SkIRect& src, const SkRect& dst, const SkPaint* paint)
+            : image(std::move(image)), xs(xs), ys(ys), fs(fs), src(src), dst(dst) {
             if (paint) { this->paint = *paint; }
         }
         sk_sp<const SkImage> image;
         int                  xs, ys, fs;
+        SkIRect              src;
         SkRect               dst;
         SkPaint              paint;
         void draw(SkCanvas* c, const SkMatrix&) {
             auto xdivs = pod<int>(this, 0),
                  ydivs = pod<int>(this, xs*sizeof(int));
             auto flags = (0 == fs) ? nullptr :
                                      pod<SkCanvas::Lattice::Flags>(this, (xs+ys)*sizeof(int));
-            c->drawImageLattice(image.get(), {xdivs, ydivs, flags, xs, ys}, dst, &paint);
+            c->drawImageLattice(image.get(), {xdivs, ydivs, flags, xs, ys, &src}, dst, &paint);
         }
     };
 
     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;
@@ skipping 282 matching lines @@
 }
 void SkLiteDL::drawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
                               const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     this->push<DrawImageRect>(0, SkImage::MakeFromBitmap(bm), src, dst, paint, constraint);
 }
 void SkLiteDL::drawBitmapLattice(const SkBitmap& bm, const SkCanvas::Lattice& lattice,
                                  const SkRect& dst, const SkPaint* paint) {
     int xs = lattice.fXCount, ys = lattice.fYCount;
     int fs = lattice.fFlags ? (xs + 1) * (ys + 1) : 0;
     size_t bytes = (xs + ys) * sizeof(int) + fs * sizeof(SkCanvas::Lattice::Flags);
-    void* pod = this->push<DrawImageLattice>(bytes, SkImage::MakeFromBitmap(bm), xs, ys, fs, dst,
-                                             paint);
+    SkASSERT(lattice.fBounds);
+    void* pod = this->push<DrawImageLattice>(bytes, SkImage::MakeFromBitmap(bm), xs, ys, fs,
+                                             *lattice.fBounds, dst, paint);
     copy_v(pod, lattice.fXDivs, xs,
                 lattice.fYDivs, ys,
                 lattice.fFlags, fs);
 }
 
 void SkLiteDL::drawImage(const SkImage* image, SkScalar x, SkScalar y, const SkPaint* paint) {
     this->push<DrawImage>(0, sk_ref_sp(image), x,y, paint);
 }
 void SkLiteDL::drawImageNine(const SkImage* image, const SkIRect& center,
                              const SkRect& dst, const SkPaint* paint) {
     this->push<DrawImageNine>(0, sk_ref_sp(image), center, dst, paint);
 }
 void SkLiteDL::drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                              const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     this->push<DrawImageRect>(0, sk_ref_sp(image), src, dst, paint, constraint);
 }
 void SkLiteDL::drawImageLattice(const SkImage* image, const SkCanvas::Lattice& lattice,
                                 const SkRect& dst, const SkPaint* paint) {
     int xs = lattice.fXCount, ys = lattice.fYCount;
     int fs = lattice.fFlags ? (xs + 1) * (ys + 1) : 0;
     size_t bytes = (xs + ys) * sizeof(int) + fs * sizeof(SkCanvas::Lattice::Flags);
-    void* pod = this->push<DrawImageLattice>(bytes, sk_ref_sp(image), xs, ys, fs, dst, paint);
+    SkASSERT(lattice.fBounds);
+    void* pod = this->push<DrawImageLattice>(bytes, sk_ref_sp(image), xs, ys, fs, *lattice.fBounds,
+                                             dst, paint);
     copy_v(pod, lattice.fXDivs, xs,
                 lattice.fYDivs, ys,
                 lattice.fFlags, fs);
 }
 
 void SkLiteDL::drawText(const void* text, size_t bytes,
                         SkScalar x, SkScalar y, const SkPaint& paint) {
     void* pod = this->push<DrawText>(bytes, bytes, x, y, paint);
     copy_v(pod, (const char*)text,bytes);
 }
@@ skipping 120 matching lines @@
     };
 
     // TODO: single-draw specializations
 
     return fallback_plan();
 }
 
 void SkLiteDL::setBounds(const SkRect& bounds) {
     fBounds = bounds;
 }