remove dead code from SK_SUPPORT_LEGACY_BLITANTIH2V2

src/core/SkScan_Hairline.cpp

 /*
  * 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.
  */
 
 #include "SkScan.h"
 #include "SkBlitter.h"
 #include "SkRasterClip.h"
@@ skipping 200 matching lines @@
         return idx + (idy >> 1);
     } else {
         return idy + (idx >> 1);
     }
 }
 
 static void hairquad(const SkPoint pts[3], const SkRegion* clip,
                      SkBlitter* blitter, int level, SkScan::HairRgnProc lineproc) {
     SkASSERT(level <= kMaxQuadSubdivideLevel);
 
-#ifdef SK_SUPPORT_LEGACY_BLITANTIH2V2
-    if (level > 0) {
-        SkPoint tmp[5];
-
-        SkChopQuadAtHalf(pts, tmp);
-        hairquad(tmp, clip, blitter, level - 1, lineproc);
-        hairquad(&tmp[2], clip, blitter, level - 1, lineproc);
-    } else {
-        SkPoint tmp[] = { pts[0], pts[2] };
-        lineproc(tmp, 2, clip, blitter);
-    }
-#else
     SkPoint coeff[3];
     SkQuadToCoeff(pts, coeff);
 
     const int lines = 1 << level;
     Sk2s t(0);
     Sk2s dt(SK_Scalar1 / lines);
 
     SkPoint tmp[(1 << kMaxQuadSubdivideLevel) + 1];
     SkASSERT((unsigned)lines < SK_ARRAY_COUNT(tmp));
 
     tmp[0] = pts[0];
     Sk2s A = Sk2s::Load(&coeff[0].fX);
     Sk2s B = Sk2s::Load(&coeff[1].fX);
     Sk2s C = Sk2s::Load(&coeff[2].fX);
     for (int i = 1; i < lines; ++i) {
         t += dt;
         ((A * t + B) * t + C).store(&tmp[i].fX);
     }
     tmp[lines] = pts[2];
     lineproc(tmp, lines + 1, clip, blitter);
-#endif
 }
 
-#ifndef SK_SUPPORT_LEGACY_BLITANTIH2V2
 static inline Sk2s abs(const Sk2s& value) {
     return Sk2s::Max(value, -value);
 }
 
 static inline SkScalar max_component(const Sk2s& value) {
     SkScalar components[2];
     value.store(components);
     return SkTMax(components[0], components[1]);
 }
 
@@ skipping 57 matching lines @@
     Sk2s B = Sk2s::Load(&coeff[1].fX);
     Sk2s C = Sk2s::Load(&coeff[2].fX);
     Sk2s D = Sk2s::Load(&coeff[3].fX);
     for (int i = 1; i < lines; ++i) {
         t += dt;
         (((A * t + B) * t + C) * t + D).store(&tmp[i].fX);
     }
     tmp[lines] = pts[3];
     lineproc(tmp, lines + 1, clip, blitter);
 }
-#endif
 
 static inline void haircubic(const SkPoint pts[4], const SkRegion* clip,
                       SkBlitter* blitter, int level, SkScan::HairRgnProc lineproc) {
-#ifdef SK_SUPPORT_LEGACY_BLITANTIH2V2
-    if (level > 0) {
-        SkPoint tmp[7];
-
-        SkChopCubicAt(pts, tmp, SK_Scalar1/2);
-        haircubic(tmp, clip, blitter, level - 1, lineproc);
-        haircubic(&tmp[3], clip, blitter, level - 1, lineproc);
-    } else {
-        SkPoint tmp[] = { pts[0], pts[3] };
-        lineproc(tmp, 2, clip, blitter);
-    }
-#else
     if (quick_cubic_niceness_check(pts)) {
         hair_cubic(pts, clip, blitter, lineproc);
     } else {
         SkPoint  tmp[13];
         SkScalar tValues[3];
 
         int count = SkChopCubicAtMaxCurvature(pts, tmp, tValues);
         for (int i = 0; i < count; i++) {
             hair_cubic(&tmp[i * 3], clip, blitter, lineproc);
         }
     }
-#endif
 }
 
 static int compute_quad_level(const SkPoint pts[3]) {
     int d = compute_int_quad_dist(pts);
     /*  quadratics approach the line connecting their start and end points
      4x closer with each subdivision, so we compute the number of
      subdivisions to be the minimum need to get that distance to be less
      than a pixel.
      */
     int level = (33 - SkCLZ(d)) >> 1;
@@ skipping 146 matching lines @@
 
         SkAAClipBlitterWrapper wrap;
         if (!clip.quickContains(r.roundOut().makeOutset(1, 1))) {
             wrap.init(clip, blitter);
             blitter = wrap.getBlitter();
             clipRgn = &wrap.getRgn();
         }
         AntiHairLineRgn(pts, count, clipRgn, blitter);
     }
 }