Modernize and trim down SkOnce.

src/core/SkTaskGroup.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkOnce.h"
 #include "SkSemaphore.h"
 #include "SkSpinlock.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 
 #if defined(SK_BUILD_FOR_WIN32)
     static void query_num_cores(int* num_cores) {
         SYSTEM_INFO sysinfo;
         GetNativeSystemInfo(&sysinfo);
         *num_cores = sysinfo.dwNumberOfProcessors;
     }
 #else
     #include <unistd.h>
     static void query_num_cores(int* num_cores) {
         *num_cores = (int)sysconf(_SC_NPROCESSORS_ONLN);
     }
 #endif
 
-// We cache sk_num_cores() so we only query the OS once.
-SK_DECLARE_STATIC_ONCE(g_query_num_cores_once);
 int sk_num_cores() {
+    // We cache sk_num_cores() so we only query the OS once.
     static int num_cores = 0;
-    SkOnce(&g_query_num_cores_once, query_num_cores, &num_cores);
+    static SkOnce once;

[bungeman-skia, 2016/04/18 15:19:00]

It is not entirely clear to me how using member initializers solves the issue of
initializing this value.

[mtklein, 2016/04/18 15:27:44]

It makes the default constructor for SkOnce constexpr.  The SkOnce comes
pre-initialized.

+    once(query_num_cores, &num_cores);
     SkASSERT(num_cores > 0);
     return num_cores;
 }
 
 namespace {
 
 class ThreadPool : SkNoncopyable {
 public:
     static void Add(std::function<void(void)> fn, SkAtomic<int32_t>* pending) {
         if (!gGlobal) {
@@ skipping 156 matching lines @@
 
 SkTaskGroup::Enabler::~Enabler() { delete ThreadPool::gGlobal; }
 
 SkTaskGroup::SkTaskGroup() : fPending(0) {}
 
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(std::function<void(void)> fn) { ThreadPool::Add(fn, &fPending); }
 void SkTaskGroup::batch(int N, std::function<void(int)> fn) {
     ThreadPool::Batch(N, fn, &fPending);
 }