If we swap its arguments, SkTaskGroup::batch() _is_ sk_parallel_for.

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 "SkRunnable.h"
 #include "SkSemaphore.h"
@@ skipping 36 matching lines @@
         gGlobal->add([task]() { task->run(); }, pending);
     }
 
     static void Add(std::function<void(void)> fn, SkAtomic<int32_t>* pending) {
         if (!gGlobal) {
             return fn();
         }
         gGlobal->add(fn, pending);
     }
 
-    static void Batch(std::function<void(int)> fn, int N, SkAtomic<int32_t>* pending) {
+    static void Batch(int N, std::function<void(int)> fn, SkAtomic<int32_t>* pending) {
         if (!gGlobal) {
             for (int i = 0; i < N; i++) { fn(i); }
             return;
         }
-        gGlobal->batch(fn, N, pending);
+        gGlobal->batch(N, fn, pending);
     }
 
     static void Wait(SkAtomic<int32_t>* pending) {
         if (!gGlobal) {  // If we have no threads, the work must already be done.
             SkASSERT(pending->load(sk_memory_order_relaxed) == 0);
             return;
         }
         // Acquire pairs with decrement release here or in Loop.
         while (pending->load(sk_memory_order_acquire) > 0) {
             // Lend a hand until our SkTaskGroup of interest is done.
@@ skipping 62 matching lines @@
     void add(std::function<void(void)> fn, SkAtomic<int32_t>* pending) {
         Work work = { fn, pending };
         pending->fetch_add(+1, sk_memory_order_relaxed);  // No barrier needed.
         {
             AutoLock lock(&fWorkLock);
             fWork.push_back(work);
         }
         fWorkAvailable.signal(1);
     }
 
-    void batch(std::function<void(int)> fn, int N, SkAtomic<int32_t>* pending) {
+    void batch(int N, std::function<void(int)> fn, SkAtomic<int32_t>* pending) {
         pending->fetch_add(+N, sk_memory_order_relaxed);  // No barrier needed.
         {
             AutoLock lock(&fWorkLock);
             for (int i = 0; i < N; i++) {
                 Work work = { [i, fn]() { fn(i); }, pending };
                 fWork.push_back(work);
             }
         }
         fWorkAvailable.signal(N);
     }
@@ skipping 33 matching lines @@
     // and that's the only way to decrement fWorkAvailable.
     // So fWorkAvailable may overcount actual the work available.
     // We make do, but this means some worker threads may wake spuriously.
     SkSemaphore fWorkAvailable;
 
     // These are only changed in a single-threaded context.
     SkTDArray<SkThread*> fThreads;
     static ThreadPool* gGlobal;
 
     friend struct SkTaskGroup::Enabler;
-    friend int ::sk_parallel_for_thread_count();
 };
 ThreadPool* ThreadPool::gGlobal = nullptr;
 
 }  // namespace
 
 SkTaskGroup::Enabler::Enabler(int threads) {
     SkASSERT(ThreadPool::gGlobal == nullptr);
     if (threads != 0) {
         ThreadPool::gGlobal = new ThreadPool(threads);
     }
 }
 
 SkTaskGroup::Enabler::~Enabler() { delete ThreadPool::gGlobal; }
 
 SkTaskGroup::SkTaskGroup() : fPending(0) {}
 
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(SkRunnable* task)             { ThreadPool::Add(task, &fPending); }
 void SkTaskGroup::add(std::function<void(void)> fn) { ThreadPool::Add(fn, &fPending); }
-void SkTaskGroup::batch (std::function<void(int)> fn, int N) {
-    ThreadPool::Batch(fn, N, &fPending);
+void SkTaskGroup::batch(int N, std::function<void(int)> fn) {
+    ThreadPool::Batch(N, fn, &fPending);
 }
 
-int sk_parallel_for_thread_count() {
-    if (ThreadPool::gGlobal != nullptr) {
-        return ThreadPool::gGlobal->fThreads.count();
-    }
-    return 0;
-}