move private test for sect_with_horizontal into unittests

src/core/SkLineClipper.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLineClipper.h"
 
 template <typename T> T pin_unsorted(T value, T limit0, T limit1) {
     if (limit1 < limit0) {
         SkTSwap(limit0, limit1);
     }
     // now the limits are sorted
     SkASSERT(limit0 <= limit1);
 
     if (value < limit0) {
         value = limit0;
     } else if (value > limit1) {
         value = limit1;
     }
     return value;
 }
 
+// This is an example of why we need to pin the result computed in
+// sect_with_horizontal. If we didn't explicitly pin, is_between_unsorted would
+// fail.
+//
+#if 0
+static void sect_with_horizontal_test_for_pin_results() {
+    const SkPoint pts[] = {
+        { -540000,    -720000 },
+        { -9.10000017e-05f, 9.99999996e-13f }
+    };
+    float x = sect_with_horizontal(pts, 0);
+    SkASSERT(is_between_unsorted(x, pts[0].fX, pts[1].fX));
+}
+#endif
+
 // return X coordinate of intersection with horizontal line at Y
 static SkScalar sect_with_horizontal(const SkPoint src[2], SkScalar Y) {
     SkScalar dy = src[1].fY - src[0].fY;
     if (SkScalarNearlyZero(dy)) {
         return SkScalarAve(src[0].fX, src[1].fX);
     } else {
         // need the extra precision so we don't compute a value that exceeds
         // our original limits
         double X0 = src[0].fX;
         double Y0 = src[0].fY;
@@ skipping 115 matching lines @@
 static bool is_between_unsorted(SkScalar value,
                                 SkScalar limit0, SkScalar limit1) {
     if (limit0 < limit1) {
         return limit0 <= value && value <= limit1;
     } else {
         return limit1 <= value && value <= limit0;
     }
 }
 #endif
 
-#ifdef SK_DEBUG
-// This is an example of why we need to pin the result computed in
-// sect_with_horizontal. If we didn't explicitly pin, is_between_unsorted would
-// fail.
-//
-static void sect_with_horizontal_test_for_pin_results() {
-    const SkPoint pts[] = {
-        { -540000,    -720000 },
-        { -9.10000017e-05f, 9.99999996e-13f }
-    };
-    float x = sect_with_horizontal(pts, 0);
-    SkASSERT(is_between_unsorted(x, pts[0].fX, pts[1].fX));
-}
-#endif
-
 int SkLineClipper::ClipLine(const SkPoint pts[], const SkRect& clip, SkPoint lines[],
                             bool canCullToTheRight) {
-
-#ifdef SK_DEBUG
-    {
-        static bool gOnce;

[mtklein, 2016/08/17 13:12:53]

If you want to keep this and make it thread safe, you should be able to just
write:

    static SkOnce once;
    once(sect_with_horizontal_test_for_pin_results);

-        if (!gOnce) {
-            sect_with_horizontal_test_for_pin_results();
-            gOnce = true;
-        }
-    }
-#endif
-
     int index0, index1;
 
     if (pts[0].fY < pts[1].fY) {
         index0 = 0;
         index1 = 1;
     } else {
         index0 = 1;
         index1 = 0;
     }
 
@@ skipping 80 matching lines @@
     if (reverse) {
         // copy the pts in reverse order to maintain winding order
         for (int i = 0; i <= lineCount; i++) {
             lines[lineCount - i] = result[i];
         }
     } else {
         memcpy(lines, result, (lineCount + 1) * sizeof(SkPoint));
     }
     return lineCount;
 }