Change SkTaskGroup to use std::function.

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 1090 matching lines @@
     // CPU tests run on any thread.  GPU tests depend on --gpu_threading.
     SkTArray<Task> enclaves[kNumEnclaves];
     for (int j = 0; j < gSinks.count(); j++) {
         SkTArray<Task>& tasks = enclaves[gSinks[j]->enclave()];
         for (int i = 0; i < gSrcs.count(); i++) {
             tasks.push_back(Task(gSrcs[i], gSinks[j]));
         }
     }
 
     SkTaskGroup tg;
-    tg.batch(run_test, gThreadedTests.begin(), gThreadedTests.count());
+    tg.batch([](int i){ run_test(&gThreadedTests[i]); }, gThreadedTests.count());
     for (int i = 0; i < kNumEnclaves; i++) {
+        SkTArray<Task>* currentEnclave = &enclaves[i];
         switch(i) {
             case kAnyThread_Enclave:
-                tg.batch(Task::Run, enclaves[i].begin(), enclaves[i].count());
+                tg.batch([currentEnclave](int j) { Task::Run(&(*currentEnclave)[j]); }, currentEnclave->count());
                 break;
             case kGPU_Enclave:
-                tg.add(run_enclave_and_gpu_tests, &enclaves[i]);
+                tg.add([currentEnclave](){ run_enclave_and_gpu_tests(currentEnclave); });
                 break;
             default:
-                tg.add(run_enclave, &enclaves[i]);
+                tg.add([currentEnclave](){ run_enclave(currentEnclave); });
                 break;
         }
     }
     tg.wait();
     // At this point we're back in single-threaded land.
     sk_tool_utils::release_portable_typefaces();
 
     if (FLAGS_verbose && gNoteTally.count() > 0) {
         SkDebugf("\nNote tally:\n");
         gNoteTally.foreach([](const SkString& note, int* tally) {
@@ skipping 35 matching lines @@
     test(reporter, context->fGrContext);
 }
 template<>
 void call_test(TestWithGrContextAndGLContext test, skiatest::Reporter* reporter,
                GrContextFactory::ContextInfo* context) {
     test(reporter, context->fGrContext, context->fGLContext);
 }
 #endif
 } // namespace
 
-
 template<typename T>
 void RunWithGPUTestContexts(T test, GPUTestContexts testContexts, Reporter* reporter,
                             GrContextFactory* factory) {
 #if SK_SUPPORT_GPU
     const GrGLStandard api = get_gpu_api();
     for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
         int contextSelector = kNone_GPUTestContexts;
         if (GrContextFactory::IsRenderingGLContext(glCtxType)) {
             contextSelector |= kAllRendering_GPUTestContexts;
@@ skipping 30 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