Revert of SkThreadPool ~~> SkTaskGroup

tests/skia_test.cpp

 /*
  * Copyright 2011 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 "OverwriteLine.h"
 #include "Resources.h"
 #include "SkCommonFlags.h"
 #include "SkGraphics.h"
 #include "SkOSFile.h"
 #include "SkTArray.h"
-#include "SkTaskGroup.h"
 #include "SkTemplates.h"
+#include "SkThreadPool.h"
 #include "SkTime.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #endif
 
 using namespace skiatest;
 
@@ skipping 20 matching lines @@
 
 private:
     const TestRegistry* fReg;
 };
 
 class DebugfReporter : public Reporter {
 public:
     explicit DebugfReporter(int total) : fDone(0), fTotal(total) {}
 
     virtual bool allowExtendedTest() const SK_OVERRIDE { return FLAGS_extendedTest; }
+    virtual bool allowThreaded()     const SK_OVERRIDE { return !FLAGS_single; }
     virtual bool verbose()           const SK_OVERRIDE { return FLAGS_veryVerbose; }
 
 protected:
     virtual void onReportFailed(const SkString& desc) SK_OVERRIDE {
         SkDebugf("\nFAILED: %s", desc.c_str());
     }
 
     virtual void onEnd(Test* test) SK_OVERRIDE {
         const int done = 1 + sk_atomic_inc(&fDone);
 
@@ skipping 100 matching lines @@
             toRun++;
         }
         total++;
     }
 
     // Now run them.
     iter.reset();
     int32_t failCount = 0;
     int skipCount = 0;
 
-    SkTaskGroup::Enabler enabled(FLAGS_threads);
-    SkTaskGroup cpuTests;
+    SkThreadPool threadpool(FLAGS_threads);
     SkTArray<Test*> gpuTests;  // Always passes ownership to an SkTestRunnable
 
     DebugfReporter reporter(toRun);
     for (int i = 0; i < total; i++) {
         SkAutoTDelete<Test> test(iter.next(&reporter));
         if (!should_run(test->getName(), test->isGPUTest())) {
             ++skipCount;
         } else if (test->isGPUTest()) {
             gpuTests.push_back() = test.detach();
         } else {
-            cpuTests.add(SkNEW_ARGS(SkTestRunnable, (test.detach(), &failCount)));
+            threadpool.add(SkNEW_ARGS(SkTestRunnable, (test.detach(), &failCount)));
         }
     }
 
 #if SK_SUPPORT_GPU
     // Give GPU tests a context factory if that makes sense on this machine.
     GrContextFactory grContextFactory;
     for (int i = 0; i < gpuTests.count(); i++) {
         gpuTests[i]->setGrContextFactory(&grContextFactory);
     }
 #endif
 
     // Run GPU tests on this thread.
     for (int i = 0; i < gpuTests.count(); i++) {
         SkNEW_ARGS(SkTestRunnable, (gpuTests[i], &failCount))->run();
     }
 
     // Block until threaded tests finish.
-    cpuTests.wait();
+    threadpool.wait();
 
     if (FLAGS_verbose) {
         SkDebugf("\nFinished %d tests, %d failures, %d skipped. (%d internal tests)",
                  toRun, failCount, skipCount, reporter.countTests());
     }
     SkGraphics::Term();
 
     SkDebugf("\n");
     return (failCount == 0) ? 0 : 1;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return test_main();
 }
 #endif