Add test cases for Clamp and Repeat tiles.

src/core/SkLinearBitmapPipeline_core.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_core_DEFINED
 #define SkLinearBitmapPipeline_core_DEFINED
 
+#include <cmath>
+
 // Tweak ABI of functions that pass Sk4f by value to pass them via registers.
 #if defined(_MSC_VER) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
     #define VECTORCALL __vectorcall
 #elif defined(SK_CPU_ARM32) && defined(SK_ARM_HAS_NEON)
     #define VECTORCALL __attribute__((pcs("aapcs-vfp")))
 #else
     #define VECTORCALL
 #endif
 
 namespace {
 struct X {
     explicit X(SkScalar val) : fVal{val} { }
     explicit X(SkPoint pt)   : fVal{pt.fX} { }
     explicit X(SkSize s)     : fVal{s.fWidth} { }
-    explicit X(SkISize s)    : fVal(s.fWidth) { }
+    explicit X(SkISize s)    : fVal((SkScalar)s.fWidth) { }
     operator SkScalar () const {return fVal;}
 private:
     SkScalar fVal;
 };
 
 struct Y {
     explicit Y(SkScalar val) : fVal{val} { }
     explicit Y(SkPoint pt)   : fVal{pt.fY} { }
     explicit Y(SkSize s)     : fVal{s.fHeight} { }
-    explicit Y(SkISize s)    : fVal(s.fHeight) { }
+    explicit Y(SkISize s)    : fVal((SkScalar)s.fHeight) { }
     operator SkScalar () const {return fVal;}
 private:
     SkScalar fVal;
 };
 
 // The Span class enables efficient processing horizontal spans of pixels.
 // * start - the point where to start the span.
 // * length - the number of pixels to traverse in source space.
 // * count - the number of pixels to produce in destination space.
 // Both start and length are mapped through the inversion matrix to produce values in source
@@ skipping 20 matching lines @@
     SkScalar length() const { return fLength; }
     SkScalar startX() const { return X(fStart); }
     SkScalar endX() const { return startX() + length(); }
     void clear() {
         fCount = 0;
     }
 
     bool completelyWithin(SkScalar xMin, SkScalar xMax) const {
         SkScalar sMin, sMax;
         std::tie(sMin, sMax) = std::minmax(startX(), endX());
-        return xMin <= sMin && sMax <= xMax;
+        return xMin <= sMin && sMax < xMax;
     }
 
     void offset(SkScalar offsetX) {
         fStart.offset(offsetX, 0.0f);
     }
 
     Span breakAt(SkScalar breakX, SkScalar dx) {
         SkASSERT(std::isfinite(breakX));
         SkASSERT(std::isfinite(dx));
         SkASSERT(dx != 0.0f);
 
         if (this->isEmpty()) {
             return Span{{0.0, 0.0}, 0.0f, 0};
         }
 
         int dxSteps = SkScalarFloorToInt((breakX - this->startX()) / dx);
+
+        // Calculate the values for the span to cleave off.
+        SkScalar newLength = dxSteps * dx;
+
         if (dxSteps < 0) {
             // The span is wholly after breakX.
             return Span{{0.0, 0.0}, 0.0f, 0};
-        } else if (dxSteps > fCount) {
+        } else if (dxSteps >= fCount) {
             // The span is wholly before breakX.
             Span answer = *this;
             this->clear();
             return answer;
         }
 
-        // Calculate the values for the span to cleave off.
+        // If the last (or first if count = 1) sample lands directly on the boundary. Include it
+        // when dx < 0 and exclude it when dx > 0.
+        // Reasoning:
+        //  dx > 0: The sample point on the boundary is part of the next span because the entire
+        // pixel is after the boundary.
+        //  dx < 0: The sample point on the boundary is part of the current span because the
+        // entire pixel is before the boundary.
+        if (startX() + newLength == breakX && dx > 0) {
+            if (dxSteps != 0) {
+                dxSteps -= 1;
+                newLength -= dx;
+            } else {
+                return Span{{0.0, 0.0}, 0.0f, 0};
+            }
+        }
+
         SkPoint newStart = fStart;
-        SkScalar newLength = dxSteps * dx;
         int newCount = dxSteps + 1;
         SkASSERT(newCount > 0);
 
         // Update this span to reflect the break.
         SkScalar lengthToStart = newLength + dx;
         fLength -= lengthToStart;
         fCount -= newCount;
         fStart = {this->startX() + lengthToStart, Y(fStart)};
 
         return Span{newStart, newLength, newCount};
@@ skipping 86 matching lines @@
     // never used.
     while (count > 0) {
         next->bilerpList(xs, ys);
         xs = xs + dx;
         count -= 1;
     }
 }
 }  // namespace
 
 #endif // SkLinearBitmapPipeline_core_DEFINED