Modernize SkSpinlock.

dm/DM.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 "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 63 matching lines @@
 static SkTArray<SkString> gFailures;
 
 static void fail(const SkString& err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
     gFailures.push_back(err);
 }
 
 
 // We use a spinlock to make locking this in a signal handler _somewhat_ safe.
-SK_DECLARE_STATIC_SPINLOCK(gMutex);
+static SkSpinlock gMutex;
 static int32_t            gPending;
 static SkTArray<SkString> gRunning;
 
 static void done(const char* config, const char* src, const char* srcOptions, const char* name) {
     SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
     int pending;
     {
-        SkAutoTAcquire<SkPODSpinlock> lock(gMutex);
+        SkAutoTAcquire<SkSpinlock> lock(gMutex);
         for (int i = 0; i < gRunning.count(); i++) {
             if (gRunning[i] == id) {
                 gRunning.removeShuffle(i);
                 break;
             }
         }
         pending = --gPending;
     }
     // We write our dm.json file every once in a while in case we crash.
     // Notice this also handles the final dm.json when pending == 0.
     if (pending % 500 == 0) {
         JsonWriter::DumpJson();
     }
 }
 
 static void start(const char* config, const char* src, const char* srcOptions, const char* name) {
     SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
-    SkAutoTAcquire<SkPODSpinlock> lock(gMutex);
+    SkAutoTAcquire<SkSpinlock> lock(gMutex);
     gRunning.push_back(id);
 }
 
 static void print_status() {
     static SkMSec start_ms = SkTime::GetMSecs();
 
     int curr = sk_tools::getCurrResidentSetSizeMB(),
         peak = sk_tools::getMaxResidentSetSizeMB();
     SkString elapsed = HumanizeMs(SkTime::GetMSecs() - start_ms);
 
-    SkAutoTAcquire<SkPODSpinlock> lock(gMutex);
+    SkAutoTAcquire<SkSpinlock> lock(gMutex);
     SkDebugf("\n%s elapsed, %d active, %d queued, %dMB RAM, %dMB peak\n",
              elapsed.c_str(), gRunning.count(), gPending - gRunning.count(), curr, peak);
     for (auto& task : gRunning) {
         SkDebugf("\t%s\n", task.c_str());
     }
 }
 
 #if defined(SK_BUILD_FOR_WIN32)
     static void setup_crash_handler() {
         // TODO: custom crash handler like below to print out what was running
@@ skipping 1010 matching lines @@
 
     // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
     SkTaskGroup parallel;
     SkTArray<Task> serial;
 
     for (auto& sink : gSinks)
     for (auto&  src : gSrcs) {
         if (src->veto(sink->flags()) ||
             is_blacklisted(sink.tag.c_str(), src.tag.c_str(),
                            src.options.c_str(), src->name().c_str())) {
-            SkAutoTAcquire<SkPODSpinlock> lock(gMutex);
+            SkAutoTAcquire<SkSpinlock> lock(gMutex);
             gPending--;
             continue;
         }
 
         Task task(src, sink);
         if (src->serial() || sink->serial()) {
             serial.push_back(task);
         } else {
             parallel.add([task] { Task::Run(task); });
         }
@@ skipping 122 matching lines @@
                                                            Reporter* reporter,
                                                            GrContextFactory* factory);
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif