Move threadpool code from include/utils to tools/threadpool.

tests/PathOpsSkpClipTest.cpp

 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkDevice.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 "SkThreadPool.h"
+#include "ThreadPool.h"
 #include "SkTime.h"
 #include "Test.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #define PATH_SLASH "\\"
     #define IN_DIR "D:\\skp\\slave"
     #define OUT_DIR "D:\\skpOut\\1\\"
 #else
     #define PATH_SLASH "/"
     #define IN_DIR "/skp/2311328-7fc2228/slave"
@@ skipping 295 matching lines @@
         , fReporter(reporter) {
     }
 
     ~TestRunner();
     void render();
     int fNumThreads;
     SkTDArray<class TestRunnable*> fRunnables;
     skiatest::Reporter* fReporter;
 };
 
-class TestRunnable : public SkRunnable {
+class TestRunnable : public Runnable {
 public:
     virtual void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
         (*fTestFun)(&fState);
     }
 
     TestState fState;
     void (*fTestFun)(TestState*);
 };
 
@@ skipping 24 matching lines @@
     }
 };
 
 TestRunner::~TestRunner() {
     for (int index = 0; index < fRunnables.count(); index++) {
         SkDELETE(fRunnables[index]);
     }
 }
 
 void TestRunner::render() {
-    SkThreadPool pool(fNumThreads);
+    ThreadPool pool(fNumThreads);
     for (int index = 0; index < fRunnables.count(); ++ index) {
         pool.add(fRunnables[index]);
     }
 }
 
 ////////////////////////////////////////////////
 
 static const char outOpDir[] = OUT_DIR "opClip";
 static const char outOldDir[] = OUT_DIR "oldClip";
 static const char outSkpDir[] = OUT_DIR "skpTest";
@@ skipping 476 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);
                 }
             }
         }
     }
 
-    int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1;
+    int threadCount = reporter->allowThreaded() ? ThreadPool::kThreadPerCore : 1;
     TestRunner testRunner(reporter, 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));
     }
@@ skipping 31 matching lines @@
 }
 
 static void testSkpClipMain(TestState* data) {
         (void) doOneDir(data, true);
 }
 
 DEF_TEST(PathOpsSkpClipThreaded, reporter) {
     if (!initTest()) {
         return;
     }
-    int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1;
+    int threadCount = reporter->allowThreaded() ? ThreadPool::kThreadPerCore : 1;
     TestRunner testRunner(reporter, threadCount);
     const int firstDirNo = 1;
     for (int dirNo = firstDirNo; dirNo <= 100; ++dirNo) {
         *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableDir,
                 (&testSkpClipMain, dirNo, &testRunner));
     }
     testRunner.render();
     TestState state;
     state.init(0, reporter);
     for (int dirNo = firstDirNo; dirNo <= 100; ++dirNo) {
@@ skipping 92 matching lines @@
     const int lastDirNo = 100;
     if (!initUberTest(firstDirNo, lastDirNo)) {
         return;
     }
     const int dirCount = lastDirNo - firstDirNo + 1;
     SkTDArray<TestResult> tests[dirCount];
     SkTDArray<SortByName*> sorted[dirCount];
     if (!buildTests(reporter, firstDirNo, lastDirNo, tests, sorted)) {
         return;
     }
-    int threadCount = reporter->allowThreaded() ? SkThreadPool::kThreadPerCore : 1;
+    int threadCount = reporter->allowThreaded() ? ThreadPool::kThreadPerCore : 1;
     TestRunner testRunner(reporter, threadCount);
     for (int dirNo = firstDirNo; dirNo <= lastDirNo; ++dirNo) {
         SkString dirName = make_in_dir_name(dirNo);
         if (!dirName.size()) {
             continue;
         }
         SkOSFile::Iter iter(dirName.c_str(), "skp");
         SkString filename;
         while (iter.next(&filename)) {
             int count;
@@ skipping 59 matching lines @@
     SkAssertResult(make_in_dir_name(dirNo).size());
     SkString filename(skipOverSept[testIndex].filename);
     TestResult state;
     state.test(dirNo, filename);
     if (reporter->verbose()) {
         SkDebugf("%s", state.status().c_str());
     }
     state.fTestStep = kEncodeFiles;
     state.testOne();
 }