Add a src rect to drawImageLattice() API

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 938 matching lines @@
      *  - The center is stretched in both axes.
      * Else, for each axis where dst < bitmap,
      *  - The corners shrink proportionally
      *  - The sides (along the shrink axis) and center are not drawn
      */
     void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst,
                         const SkPaint* paint = NULL);
 
     /**
      *  Specifies coordinates to divide a bitmap into (xCount*yCount) rects.
+     *
+     *  If the lattice divs or bounds are invalid, the entire lattice
+     *  struct will be ignored on the draw call.
      */
     struct Lattice {
         enum Flags : uint8_t {
             // If set, indicates that we should not draw corresponding rect.
             kTransparent_Flags = 1 << 0,
         };
 
         // An array of x-coordinates that divide the bitmap vertically.
-        // These must be unique, increasing, and in the set [0, width).
+        // These must be unique, increasing, and in the set [fBounds.fLeft, fBounds.fRight).
         // Does not have ownership.
-        const int*   fXDivs;
+        const int*     fXDivs;
 
         // An array of y-coordinates that divide the bitmap horizontally.
-        // These must be unique, increasing, and in the set [0, height).
+        // These must be unique, increasing, and in the set [fBounds.fTop, fBounds.fBottom).
         // Does not have ownership.
-        const int*   fYDivs;
+        const int*     fYDivs;
 
         // If non-null, the length of this array must be equal to
         // (fXCount + 1) * (fYCount + 1).  Note that we allow the first rect
-        // in each direction to empty (divs[0] = 0).  In this case, the
-        // caller still must specify a flag (as a placeholder) for these
-        // empty rects.
+        // in each direction to be empty (ex: fXDivs[0] = fBounds.fLeft).
+        // In this case, the caller still must specify a flag (as a placeholder)
+        // for these empty rects.
         // The flags correspond to the rects in the lattice, first moving
         // left to right and then top to bottom.
-        const Flags* fFlags;
+        const Flags*   fFlags;
 
         // The number of fXDivs.
-        int          fXCount;
+        int            fXCount;
 
         // The number of fYDivs.
-        int          fYCount;
+        int            fYCount;
+
+        // The bound to draw from.  Must be contained by the src that is being drawn,
+        // non-empty, and non-inverted.
+        // If nullptr, the bounds are the entire src.
+        const SkIRect* fBounds;
     };
 
     /**
      *  Draw the bitmap stretched or shrunk differentially to fit into dst.
      *
      *  Moving horizontally across the bitmap, alternating rects will be "scalable"
      *  (in the x-dimension) to fit into dst or must be left "fixed".  The first rect
      *  is treated as "fixed", but it's possible to specify an empty first rect by
      *  making lattice.fXDivs[0] = 0.
      *
@@ skipping 755 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkCanvas::ClipOp, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkCanvas::ClipOp, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkCanvas::ClipOp, bool antialias) = 0;
 };
 
 #endif