Simplify code by breaking general sampler into Nearest and Bilerp.

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
 
@@ skipping 170 matching lines @@
         stage->pointList4(xs, ys);
         xs = xs + fourDx;
         count -= 4;
     }
     if (count > 0) {
         stage->pointListFew(count, xs, ys);
     }
 }
 }  // namespace
 
+class SkLinearBitmapPipeline::PointProcessorInterface {
+public:
+    virtual ~PointProcessorInterface() { }
+    // Take the first n (where 0 < n && n < 4) items from xs and ys and sample those points. For
+    // nearest neighbor, that means just taking the floor xs and ys. For bilerp, this means
+    // to expand the bilerp filter around the point and sample using that filter.
+    virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
+    // Same as pointListFew, but n = 4.
+    virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
+    // A span is a compact form of sample points that are obtained by mapping points from
+    // destination space to source space. This is used for horizontal lines only, and is mainly
+    // used to take advantage of memory coherence for horizontal spans.
+    virtual void pointSpan(Span span) = 0;
+};
+
+class SkLinearBitmapPipeline::SampleProcessorInterface
+    : public SkLinearBitmapPipeline::PointProcessorInterface {
+public:
+    // Used for nearest neighbor when scale factor is 1.0. The span can just be repeated with no
+    // edge pixel alignment problems. This is for handling a very common case.
+    virtual void repeatSpan(Span span, int32_t repeatCount) = 0;
+
+    // The x's and y's are setup in the following order:
+    // +--------+--------+
+    // |        |        |
+    // |  px00  |  px10  |
+    // |    0   |    1   |
+    // +--------+--------+
+    // |        |        |
+    // |  px01  |  px11  |
+    // |    2   |    3   |
+    // +--------+--------+
+    // These pixels coordinates are arranged in the following order in xs and ys:
+    // px00  px10  px01  px11
+    virtual void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) = 0;
+
+    // A span represents sample points that have been mapped from destination space to source
+    // space. Each sample point is then expanded to the four bilerp points by add +/- 0.5. The
+    // resulting Y values my be off the tile. When y +/- 0.5 are more than 1 apart because of
+    // tiling, the second Y is used to denote the retiled Y value.
+    virtual void bilerpSpan(Span span, SkScalar y) = 0;
+};
+
+class SkLinearBitmapPipeline::DestinationInterface {
+public:
+    virtual ~DestinationInterface() { }
+    // Count is normally not needed, but in these early stages of development it is useful to
+    // check bounds.
+    // TODO(herb): 4/6/2016 - remove count when code is stable.
+    virtual void setDestination(void* dst, int count) = 0;
+};
+
+class SkLinearBitmapPipeline::BlendProcessorInterface
+    : public SkLinearBitmapPipeline::DestinationInterface {
+public:
+    virtual void VECTORCALL blendPixel(Sk4f pixel0) = 0;
+    virtual void VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
+};
+
 #endif // SkLinearBitmapPipeline_core_DEFINED