Revert of Add unit repeat tiler

src/core/SkLinearBitmapPipeline.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 "SkLinearBitmapPipeline.h"
 
 #include "SkPM4f.h"
@@ skipping 220 matching lines @@
         this->bilerpPoint(xs[1], ys[1]);
         this->bilerpPoint(xs[2], ys[2]);
         this->bilerpPoint(xs[3], ys[3]);
     }
 
     struct Wrapper {
         void pointSpan(Span span) {
             processor->breakIntoEdges(span);
         }
 
-        void repeatSpan(Span span, int32_t repeatCount) {
-            while (repeatCount --> 0) {
-                processor->pointSpan(span);
-            }
-        }
-
         BilerpTileStage* processor;
     };
 
     // The span you pass must not be empty.
     void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
 
         Wrapper wrapper = {this};
         if (!fXStrategy.maybeProcessSpan(span, &wrapper)) {
             span_fallback(span, this);
@@ skipping 106 matching lines @@
             break;
     }
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_tiler(
     SkLinearBitmapPipeline::SampleProcessorInterface* next,
     SkISize dimensions,
     SkShader::TileMode xMode,
     SkShader::TileMode yMode,
     SkFilterQuality filterQuality,
-    SkScalar dx,
-    SkLinearBitmapPipeline::TileStage* tileStage)
-{
+    SkLinearBitmapPipeline::TileStage* tileStage) {
     switch (xMode) {
         case SkShader::kClamp_TileMode:
             choose_tiler_ymode<XClampStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
         case SkShader::kRepeat_TileMode:
-            if (dx == 1.0f && filterQuality == kNone_SkFilterQuality) {
-                choose_tiler_ymode<XRepeatUnitScaleStrategy>(
-                    yMode, kNone_SkFilterQuality, dimensions, next, tileStage);
-            } else {
-                choose_tiler_ymode<XRepeatStrategy>(
-                    yMode, filterQuality, dimensions, next, tileStage);
-            }
+            choose_tiler_ymode<XRepeatStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
         case SkShader::kMirror_TileMode:
             choose_tiler_ymode<XMirrorStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
     }
 
     return tileStage->get();
 }
 
 
@@ skipping 197 matching lines @@
         if (inverse.getScaleX() >= 0.0f) {
             adjustedInverse.setTranslateX(
                 nextafterf(inverse.getTranslateX(), std::floor(inverse.getTranslateX())));
         }
         if (inverse.getScaleY() >= 0.0f) {
             adjustedInverse.setTranslateY(
                 nextafterf(inverse.getTranslateY(), std::floor(inverse.getTranslateY())));
         }
     }
 
-    SkScalar dx = adjustedInverse.getScaleX();
-
     // If it is an index 8 color type, the sampler converts to unpremul for better fidelity.
     SkAlphaType alphaType = srcImageInfo.alphaType();
     if (srcPixmap.colorType() == kIndex_8_SkColorType) {
         alphaType = kUnpremul_SkAlphaType;
     }
 
     // As the stages are built, the chooser function may skip a stage. For example, with the
     // identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
     auto placementStage = choose_pixel_placer(alphaType, postAlpha, &fPixelStage);
     auto samplerStage   = choose_pixel_sampler(placementStage,
                                                filterQuality, srcPixmap, &fSampleStage);
     auto tilerStage     = choose_tiler(samplerStage,
-                                       dimensions, xTile, yTile, filterQuality, dx, &fTiler);
+                                       dimensions, xTile, yTile, filterQuality, &fTiler);
     fFirstStage         = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     fPixelStage->setDestination(dst);
     // The count and length arguments start out in a precise relation in order to keep the
     // math correct through the different stages. Count is the number of pixel to produce.
     // Since the code samples at pixel centers, length is the distance from the center of the
     // first pixel to the center of the last pixel. This implies that length is count-1.
     fFirstStage->pointSpan(Span{{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }