Revert of SK_DECLARE_STATIC_MUTEX -> static SkMutex

src/pathops/SkPathOpsDebug.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMutex.h"
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
@@ skipping 249 matching lines @@
 
 const char* SkPathOpsDebug::OpStr(SkPathOp op) {
     return gOpStrs[op];
 }
 
 static void show_op(SkPathOp op, const char* pathOne, const char* pathTwo) {
     SkDebugf("    testPathOp(reporter, %s, %s, %s, filename);\n", pathOne, pathTwo, gOpStrs[op]);
     SkDebugf("}\n");
 }
 
-static SkMutex gTestMutex;
+SK_DECLARE_STATIC_MUTEX(gTestMutex);
 
 void SkPathOpsDebug::ShowPath(const SkPath& a, const SkPath& b, SkPathOp shapeOp,
         const char* testName) {
     SkAutoMutexAcquire ac(gTestMutex);
     show_function_header(testName);
     ShowOnePath(a, "path", true);
     ShowOnePath(b, "pathB", true);
     show_op(shapeOp, "path", "pathB");
 }
 
@@ skipping 358 matching lines @@
                 continue;
             }
             const SkOpSpan* span = spanBase->upCastable();
             // FIXME?: this assumes that if the opposite segment is coincident then no more
             // coincidence needs to be detected. This may not be true.
             if (span && span->segment() != opp && span->containsCoincidence(opp)) {
                 continue;
             }
             if (spanBase->segment() != opp && spanBase->containsCoinEnd(opp)) {
                 continue;
-            }
+            } 
             const SkOpPtT* priorPtT = nullptr, * priorStopPtT;
             // find prior span containing opp segment
             const SkOpSegment* priorOpp = nullptr;
             const SkOpSpan* priorTest = spanBase->prev();
             while (!priorOpp && priorTest) {
                 priorStopPtT = priorPtT = priorTest->ptT();
                 while ((priorPtT = priorPtT->next()) != priorStopPtT) {
                     if (priorPtT->deleted()) {
                         continue;
                     }
@@ skipping 119 matching lines @@
             foundMatch:  // merge oppTest and oppSpan
                     if (oppTest == &oppSegment->fTail || oppTest == &oppSegment->fHead) {
                         SkASSERT(oppSpan != &oppSegment->fHead); // don't expect collapse
                         SkASSERT(oppSpan != &oppSegment->fTail);
                         glitches->record(kMoveMultiple_Glitch, id, oppTest, oppSpan);
                     } else {
                         glitches->record(kMoveMultiple_Glitch, id, oppSpan, oppTest);
                     }
                     goto checkNextSpan;
                 }
-        tryNextSpan:
+        tryNextSpan: 
                 ;
             } while (oppTest != oppLast && (oppTest = oppTest->upCast()->next()));
         } while ((testPtT = testPtT->next()) != startPtT);
-checkNextSpan:
+checkNextSpan: 
         ;
     } while ((test = test->final() ? nullptr : test->upCast()->next()));
 }
 
 void SkOpSegment::debugMoveNearby(const char* id, SkPathOpsDebug::GlitchLog* glitches) const {
         const SkOpSpanBase* spanS = &fHead;
     do {
         const SkOpSpanBase* test = spanS->upCast()->next();
         const SkOpSpanBase* next;
         if (spanS->contains(test)) {
@@ skipping 147 matching lines @@
         SkDebugf("%d", span->windSum());
     }
     SkDebugf(" windValue=%d oppValue=%d\n", span->windValue(), span->oppValue());
 }
 
 #endif
 
 // loop looking for a pair of angle parts that are too close to be sorted
 /* This is called after other more simple intersection and angle sorting tests have been exhausted.
    This should be rarely called -- the test below is thorough and time consuming.
-   This checks the distance between start points; the distance between
+   This checks the distance between start points; the distance between 
 */
 #if DEBUG_ANGLE
 void SkOpAngle::debugCheckNearCoincidence() const {
     const SkOpAngle* test = this;
     do {
         const SkOpSegment* testSegment = test->segment();
         double testStartT = test->start()->t();
         SkDPoint testStartPt = testSegment->dPtAtT(testStartT);
         double testEndT = test->end()->t();
         SkDPoint testEndPt = testSegment->dPtAtT(testEndT);
@@ skipping 17 matching lines @@
             SkDebugf("%s testMidDistSq=%1.9g\n", __FUNCTION__, testMidDistSq);
             SkDebugf("%s testEndDistSq=%1.9g\n", __FUNCTION__, testEndDistSq);
             SkDebugf("%s nextMidDistSq=%1.9g\n", __FUNCTION__, nextMidDistSq);
             SkDebugf("%s nextEndDistSq=%1.9g\n", __FUNCTION__, nextEndDistSq);
             SkDPoint nextEndPt = nextSegment->dPtAtT(nextEndT);
             double nextLenSq = nextStartPt.distanceSquared(nextEndPt);
             SkDebugf("%s nextLenSq=%1.9g\n", __FUNCTION__, nextLenSq);
             SkDebugf("\n");
         }
         test = test->fNext;
-    } while (test->fNext != this);
+    } while (test->fNext != this); 
 }
 #endif
 
 #if DEBUG_ANGLE
 SkString SkOpAngle::debugPart() const {
     SkString result;
     switch (this->segment()->verb()) {
         case SkPath::kLine_Verb:
             result.printf(LINE_DEBUG_STR " id=%d", LINE_DEBUG_DATA(fCurvePart),
                     this->segment()->debugID());
@@ skipping 835 matching lines @@
 #endif
     SkPath::FillType fillType = path.getFillType();
     SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
     if (includeDeclaration) {
         SkDebugf("    SkPath %s;\n", name);
     }
     SkDebugf("    %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[fillType]);
     iter.setPath(path);
     showPathContours(iter, name);
 }