Revert of SkThreadPool ~~> SkTaskGroup

tests/PathOpsSkpClipTest.cpp

 #include "CrashHandler.h"
 // #include "OverwriteLine.h"
 #include "Resources.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkDevice.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPathOpsDebug.h"
 #include "SkPicture.h"
 #include "SkRTConf.h"
 #include "SkTSort.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
-#include "SkTaskGroup.h"
 #include "SkTemplates.h"
+#include "SkThreadPool.h"
 #include "SkTime.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 /* add local exceptions here */
 /* TODO : add command flag interface */
 const struct SkipOverTest {
     int directory;
     const char* filename;
     bool blamePathOps;
@@ skipping 48 matching lines @@
 static SkString get_in_path(int dirNo, const char* filename) {
     SkString path;
     SkASSERT(dirNo);
     path.appendf("%s%d%s", IN_DIR_PRE, dirNo, DIR_POST);
     if (!sk_exists(path.c_str())) {
         SkDebugf("could not read %s\n", path.c_str());
         return SkString();
     }
     if (filename) {
         path.appendf("%s%s", PATH_SLASH, filename);
-        if (!sk_exists(path.c_str())) {
+        if (!sk_exists(path.c_str())) {        
             SkDebugf("could not read %s\n", path.c_str());
             return SkString();
         }
     }
     return path;
 }
-
+    
 static void make_recursive_dir(const SkString& path) {
     if (sk_exists(path.c_str())) {
         return;
     }
     const char* pathStr = path.c_str();
     int last = (int) path.size();
     do {
         while (last > 0 && pathStr[--last] != PATH_SLASH[0])
             ;
         SkASSERT(last > 0);
@@ skipping 11 matching lines @@
 }
 
 static SkString get_out_path(int dirNo, const char* dirName) {
     SkString path;
     SkASSERT(dirNo);
     SkASSERT(dirName);
     path.appendf("%s%d%s%s%s", OUT_DIR_PRE, dirNo, DIR_POST, PATH_SLASH, dirName);
     make_recursive_dir(path);
     return path;
 }
-
+  
 static SkString get_sum_path(const char* dirName) {
     SkString path;
     SkASSERT(dirName);
     path.appendf("%s%d%s%s", OUT_DIR_SUM, SUMMARY_RUN, PATH_SLASH, dirName);
     SkDebugf("%s\n", path.c_str());
     make_recursive_dir(path);
     return path;
 }
 
 static SkString make_png_name(const char* filename) {
@@ skipping 16 matching lines @@
     kSmallLimit = 1000,
 };
 
 struct TestResult {
     void init(int dirNo) {
         fDirNo = dirNo;
         sk_bzero(fFilename, sizeof(fFilename));
         fTestStep = kCompareBits;
         fScale = 1;
     }
-
+    
     void init(int dirNo, const SkString& filename) {
         fDirNo = dirNo;
         strcpy(fFilename, filename.c_str());
         fTestStep = kCompareBits;
-        fScale = 1;
+        fScale = 1;       
     }
 
     SkString status() {
         SkString outStr;
         outStr.printf("%s %d %d\n", fFilename, fPixelError, fTime);
         return outStr;
     }
 
     SkString progress() {
         SkString outStr;
@@ skipping 12 matching lines @@
 
     }
 
     void test(int dirNo, const SkString& filename) {
         init(dirNo);
         strcpy(fFilename, filename.c_str());
         testOne();
     }
 
     void testOne();
-
+    
     char fFilename[kMaxLength];
     TestStep fTestStep;
     int fDirNo;
     int fPixelError;
     int fTime;
     int fScale;
 };
 
 class SortByPixel : public TestResult {
 public:
@@ skipping 20 matching lines @@
     void init(int dirNo) {
         fResult.init(dirNo);
     }
 
     SkTDArray<SortByPixel> fPixelWorst;
     SkTDArray<SortByTime> fSlowest;
     TestResult fResult;
 };
 
 struct TestRunner {
+    TestRunner(int threadCount)
+        : fNumThreads(threadCount) {
+    }
+
     ~TestRunner();
     void render();
+    int fNumThreads;
     SkTDArray<class TestRunnable*> fRunnables;
 };
 
 class TestRunnable : public SkRunnable {
 public:
     virtual void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
         (*fTestFun)(&fState);
     }
 
@@ skipping 28 matching lines @@
     }
 };
 
 TestRunner::~TestRunner() {
     for (int index = 0; index < fRunnables.count(); index++) {
         SkDELETE(fRunnables[index]);
     }
 }
 
 void TestRunner::render() {
-    SkTaskGroup tg;
+    SkThreadPool pool(fNumThreads);
     for (int index = 0; index < fRunnables.count(); ++ index) {
-        tg.add(fRunnables[index]);
+        pool.add(fRunnables[index]);
     }
 }
 
 ////////////////////////////////////////////////
 
 
 static int similarBits(const SkBitmap& gr, const SkBitmap& sk) {
     const int kRowCount = 3;
     const int kThreshold = 3;
     int width = SkTMin(gr.width(), sk.width());
@@ skipping 208 matching lines @@
         "~ causes a matching test to always be skipped\n"
         "^ requires the start of the test to match\n"
         "$ requires the end of the test to match\n"
         "^ and $ requires an exact match\n"
         "If a test does not match any list entry,\n"
         "it is skipped unless some list entry starts with ~");
 DEFINE_string2(dir, d, NULL, "range of directories (e.g., 1-100)");
 DEFINE_string2(skp, s, NULL, "skp to test");
 DEFINE_bool2(single, z, false, "run tests on a single thread internally.");
 DEFINE_int32(testIndex, 0, "override local test index (PathOpsSkpClipOneOff only).");
+DEFINE_int32(threads, SkThreadPool::kThreadPerCore,
+        "Run threadsafe tests on a threadpool with this many threads.");
 DEFINE_bool2(verbose, v, false, "enable verbose output.");
 
 static bool verbose() {
     return FLAGS_verbose;
 }
 
+static int getThreadCount() {
+    return FLAGS_single ? 1 : FLAGS_threads;
+}
+
 class Dirs {
 public:
     Dirs() {
         reset();
         sk_bzero(fRun, sizeof(fRun));
         fSet = false;
     }
 
     int first() const {
         int index = 0;
@@ skipping 53 matching lines @@
     Filenames()
         : fIndex(-1) {
     }
 
     const char* next() {
         while (fNames && ++fIndex < fNames->count()) {
             return (*fNames)[fIndex];
         }
         return NULL;
     }
-
+    
     void set(const SkCommandLineFlags::StringArray& names) {
         fNames = &names;
     }
 
 private:
     int fIndex;
     const SkCommandLineFlags::StringArray* fNames;
 } gNames;
 
-static bool buildTestDir(int dirNo, int firstDirNo,
+static bool buildTestDir(int dirNo, int firstDirNo, 
         SkTDArray<TestResult>* tests, SkTDArray<SortByName*>* sorted) {
     SkString dirName = get_out_path(dirNo, outStatusDir);
     if (!dirName.size()) {
         return false;
     }
     SkOSFile::Iter iter(dirName.c_str(), "skp");
     SkString filename;
     while (iter.next(&filename)) {
         TestResult test;
         test.init(dirNo);
@@ skipping 145 matching lines @@
             }
             if (slowest.count() > 0) {
                 SkTQSort<SortByTime>(slowest.begin(), slowest.end() - 1);
                 for (int index = 0; index < slowest.count(); ++index) {
                     const TestResult& result = *slowest[index];
                     SkDebugf("%d %s time=%d\n", result.fDirNo, result.fFilename, result.fTime);
                 }
             }
         }
     }
-    TestRunner testRunner;
+    int threadCount = getThreadCount();
+    TestRunner testRunner(threadCount);
     for (int index = 0; index < state.fPixelWorst.count(); ++index) {
         const TestResult& result = state.fPixelWorst[index];
         SkString filename(result.fFilename);
         if (!filename.endsWith(".skp")) {
             filename.append(".skp");
         }
         *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableEncode,
                 (&testSkpClipEncode, result.fDirNo, filename.c_str(), &testRunner));
     }
     testRunner.render();
@@ skipping 51 matching lines @@
     encodeFound(state);
 }
 
 static void testSkpClipMain(TestState* data) {
         (void) doOneDir(data, true);
 }
 
 DEF_TEST(PathOpsSkpClipThreaded) {
     gDirs.setDefault();
     initTest();
-    TestRunner testRunner;
+    int threadCount = getThreadCount();
+    TestRunner testRunner(threadCount);
     int dirNo;
     gDirs.reset();
     while ((dirNo = gDirs.next()) > 0) {
         *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableDir,
                 (&testSkpClipMain, dirNo, &testRunner));
     }
     testRunner.render();
     TestState state;
     state.init(0);
     gDirs.reset();
     while ((dirNo = gDirs.next()) > 0) {
         TestState& testState = testRunner.fRunnables[dirNo - 1]->fState;
         SkASSERT(testState.fResult.fDirNo == dirNo);
         for (int inner = 0; inner < testState.fPixelWorst.count(); ++inner) {
             addError(&state, testState.fPixelWorst[inner]);
         }
         for (int inner = 0; inner < testState.fSlowest.count(); ++inner) {
             addError(&state, testState.fSlowest[inner]);
         }
     }
     encodeFound(state);
 }
-
+ 
 static bool buildTests(SkTDArray<TestResult>* tests, SkTDArray<SortByName*>* sorted) {
     int firstDirNo = gDirs.first();
     int dirNo;
     while ((dirNo = gDirs.next()) > 0) {
         if (!buildTestDir(dirNo, firstDirNo, tests, sorted)) {
             return false;
         }
     }
     return true;
 }
 
 DEF_TEST(PathOpsSkpClipUberThreaded) {
     gDirs.setDefault();
     const int firstDirNo = gDirs.next();
     const int lastDirNo = gDirs.last();
     initTest();
     int dirCount = lastDirNo - firstDirNo + 1;
     SkAutoTDeleteArray<SkTDArray<TestResult> > tests(new SkTDArray<TestResult>[dirCount]);
     SkAutoTDeleteArray<SkTDArray<SortByName*> > sorted(new SkTDArray<SortByName*>[dirCount]);
     if (!buildTests(tests.get(), sorted.get())) {
         return;
     }
-    TestRunner testRunner;
+    int threadCount = getThreadCount();
+    TestRunner testRunner(threadCount);
     int dirNo;
     gDirs.reset();
     while ((dirNo = gDirs.next()) > 0) {
         SkString dirName = get_in_path(dirNo, NULL);
         if (!dirName.size()) {
             continue;
         }
         SkOSFile::Iter iter(dirName.c_str(), "skp");
         SkString filename;
         while (iter.next(&filename)) {
@@ skipping 183 matching lines @@
     }
     SkGraphics::Term();
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif