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

tools/skpdiff/SkDiffContext.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 "SkBitmap.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
-#include "SkRunnable.h"
+#include "Runnable.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkTDict.h"
-#include "SkThreadPool.h"
+#include "ThreadPool.h"
 
 #include "SkDiffContext.h"
 #include "SkImageDiffer.h"
 #include "skpdiff_util.h"
 
 SkDiffContext::SkDiffContext() {
     fDiffers = NULL;
     fDifferCount = 0;
-    fThreadCount = SkThreadPool::kThreadPerCore;
+    fThreadCount = ThreadPool::kThreadPerCore;
 }
 
 SkDiffContext::~SkDiffContext() {
     if (NULL != fDiffers) {
         SkDELETE_ARRAY(fDiffers);
     }
 }
 
 void SkDiffContext::setAlphaMaskDir(const SkString& path) {
     if (!path.isEmpty() && sk_mkdir(path.c_str())) {
@@ skipping 145 matching lines @@
                                                              newRecord->fCommonName.c_str());
             SkImageEncoder::EncodeFile(newRecord->fWhiteDiffPath.c_str(),
                                        diffData.fResult.whiteDiffBitmap,
                                        SkImageEncoder::kPNG_Type, 100);
             diffData.fResult.whiteDiffBitmap.reset();
             bitmapsToCreate.whiteDiff = false;
         }
     }
 }
 
-class SkThreadedDiff : public SkRunnable {
+class SkThreadedDiff : public Runnable {
 public:
     SkThreadedDiff() : fDiffContext(NULL) { }
 
     void setup(SkDiffContext* diffContext, const SkString& baselinePath, const SkString& testPath) {
         fDiffContext = diffContext;
         fBaselinePath = baselinePath;
         fTestPath = testPath;
     }
 
     virtual void run() SK_OVERRIDE {
         fDiffContext->addDiff(fBaselinePath.c_str(), fTestPath.c_str());
     }
 
 private:
     SkDiffContext* fDiffContext;
     SkString fBaselinePath;
     SkString fTestPath;
 };
 
 void SkDiffContext::diffDirectories(const char baselinePath[], const char testPath[]) {
     // Get the files in the baseline, we will then look for those inside the test path
     SkTArray<SkString> baselineEntries;
     if (!get_directory(baselinePath, &baselineEntries)) {
         SkDebugf("Unable to open path \"%s\"\n", baselinePath);
         return;
     }
 
-    SkThreadPool threadPool(fThreadCount);
+    ThreadPool threadPool(fThreadCount);
     SkTArray<SkThreadedDiff> runnableDiffs;
     runnableDiffs.reset(baselineEntries.count());
 
     for (int x = 0; x < baselineEntries.count(); x++) {
         const char* baseFilename = baselineEntries[x].c_str();
 
         // Find the real location of each file to compare
         SkString baselineFile = SkOSPath::SkPathJoin(baselinePath, baseFilename);
         SkString testFile = SkOSPath::SkPathJoin(testPath, baseFilename);
 
@@ skipping 25 matching lines @@
     if (!glob_files(testPattern, &testEntries)) {
         SkDebugf("Unable to get pattern \"%s\"\n", testPattern);
         return;
     }
 
     if (baselineEntries.count() != testEntries.count()) {
         SkDebugf("Baseline and test patterns do not yield corresponding number of files\n");
         return;
     }
 
-    SkThreadPool threadPool(fThreadCount);
+    ThreadPool threadPool(fThreadCount);
     SkTArray<SkThreadedDiff> runnableDiffs;
     runnableDiffs.reset(baselineEntries.count());
 
     for (int x = 0; x < baselineEntries.count(); x++) {
         runnableDiffs[x].setup(this, baselineEntries[x], testEntries[x]);
         threadPool.add(&runnableDiffs[x]);
     }
 
     threadPool.wait();
 }
@@ skipping 158 matching lines @@
         for (int i = 0; i < cntColumns; i++) {
             SkString str;
             str.printf(", %f", values[i]);
             stream.writeText(str.c_str());
         }
         stream.writeText("\n");
 
         currentRecord = iter2.next();
     }
 }