Simplify the poly union.

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 255 matching lines @@
         if (!fStrategy.maybeProcessSpan(span, fNext)) {
             span_fallback(span, this);
         }
     }
 
 private:
     Next* const fNext;
     Strategy fStrategy;
 };
 
-class SkippedStage final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
-    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
-        SkFAIL("Skipped stage.");
-    }
-    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
-        SkFAIL("Skipped stage.");
-    }
-    void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) override {
-        SkFAIL("Skipped stage.");
-    }
-    void pointSpan(Span span) override {
-        SkFAIL("Skipped stage.");
-    }
-};
-
 class TranslateMatrixStrategy {
 public:
     TranslateMatrixStrategy(SkVector offset)
         : fXOffset{X(offset)}
         , fYOffset{Y(offset)} { }
 
     void processPoints(Sk4s* xs, Sk4s* ys) {
         *xs = *xs + fXOffset;
         *ys = *ys + fYOffset;
     }
@@ skipping 82 matching lines @@
     } else if (inverse.getScaleX() != 1.0f || inverse.getScaleY() != 1.0f) {
         matrixProc->Initialize<ScaleMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
             SkVector{inverse.getScaleX(), inverse.getScaleY()});
     } else if (inverse.getTranslateX() != 0.0f || inverse.getTranslateY() != 0.0f) {
         matrixProc->Initialize<TranslateMatrix<>>(
             next,
             SkVector{inverse.getTranslateX(), inverse.getTranslateY()});
     } else {
-        matrixProc->Initialize<SkippedStage>();
         return next;
     }
     return matrixProc->get();
 }
 
 template <typename Next = SkLinearBitmapPipeline::BilerpProcessorInterface>
 class ExpandBilerp final : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
     ExpandBilerp(Next* next) : fNext{next} { }
 
@@ skipping 24 matching lines @@
 
 private:
     Next* const fNext;
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_filter(
     SkLinearBitmapPipeline::BilerpProcessorInterface* next,
     SkFilterQuality filterQuailty,
     SkLinearBitmapPipeline::FilterStage* filterProc) {
     if (SkFilterQuality::kNone_SkFilterQuality == filterQuailty) {
-        filterProc->Initialize<SkippedStage>();
         return next;
     } else {
         filterProc->Initialize<ExpandBilerp<>>(next);
         return filterProc->get();
     }
 }
 
 class ClampStrategy {
 public:
     ClampStrategy(X max)
@@ skipping 221 matching lines @@
             case SkShader::kClamp_TileMode:
                 tileProcXOrBoth->Initialize<Clamp<>>(next, dimensions);
                 break;
             case SkShader::kRepeat_TileMode:
                 tileProcXOrBoth->Initialize<Repeat<>>(next, dimensions);
                 break;
             case SkShader::kMirror_TileMode:
                 SkFAIL("Not implemented.");
                 break;
         }
-        tileProcY->Initialize<SkippedStage>();
     } else {
         switch (yMode) {
             case SkShader::kClamp_TileMode:
                 tileProcY->Initialize<Clamp<>>(next, Y(dimensions));
                 break;
             case SkShader::kRepeat_TileMode:
                 tileProcY->Initialize<Repeat<>>(next, Y(dimensions));
                 break;
             case SkShader::kMirror_TileMode:
                 SkFAIL("Not implemented.");
@@ skipping 243 matching lines @@
 
 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{SkPoint{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }