Sanitizing source files in Housekeeper-Nightly

git-svn-id: http://skia.googlecode.com/svn/trunk@12427 2bbb7eff-a529-9590-31e7-b0007b416f81

17 files changed, 131 insertions, 78 deletions

diff --git a/dm/DM.cpp b/dm/DM.cpp
index 274ec2a815..8c30fe6b55 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -6,7 +6,6 @@
 #include "SkCommandLineFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
-#include "SkString.h"
 #include "gm.h"
 
 #include "DMReporter.h"
@@ -40,6 +39,19 @@ DEFINE_string(config, "8888 gpu",
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
+// Split str on any characters in delimiters into out.  (Think, strtok with a sane API.)
+static void split(const char* str, const char* delimiters, SkTArray<SkString>* out) {
+    const char* end = str + strlen(str);
+    while (str != end) {
+        // Find a token.
+        const size_t len = strcspn(str, delimiters);
+        out->push_back().set(str, len);
+        str += len;
+        // Skip any delimiters.
+        str += strspn(str, delimiters);
+    }
+}
+
 // "FooBar" -> "foobar".  Obviously, ASCII only.
 static SkString lowercase(SkString s) {
     for (size_t i = 0; i < s.size(); i++) {
@@ -122,7 +134,7 @@ int tool_main(int argc, char** argv) {
     GM::SetResourcePath(FLAGS_resources[0]);
     SkTArray<SkString> configs;
     for (int i = 0; i < FLAGS_config.count(); i++) {
-        SkStrSplit(FLAGS_config[i], ", ", &configs);
+        split(FLAGS_config[i], ", ", &configs);
     }
 
     SkTDArray<GMRegistry::Factory> gms;
diff --git a/dm/DMComparisonTask.cpp b/dm/DMComparisonTask.cpp
new file mode 100644
index 0000000000..bb4e656754
--- /dev/null
+++ b/dm/DMComparisonTask.cpp
@@ -0,0 +1,21 @@
+#include "DMComparisonTask.h"
+#include "DMUtil.h"
+
+namespace DM {
+
+ComparisonTask::ComparisonTask(const Task& parent,
+                               skiagm::Expectations expectations,
+                               SkBitmap bitmap)
+    : Task(parent)
+    , fName(parent.name())  // Masquerade as parent so failures are attributed to it.
+    , fExpectations(expectations)
+    , fBitmap(bitmap)
+    {}
+
+void ComparisonTask::draw() {
+    if (!MeetsExpectations(fExpectations, fBitmap)) {
+        this->fail();
+    }
+}
+
+}  // namespace DM
diff --git a/dm/DMComparisonTask.h b/dm/DMComparisonTask.h
new file mode 100644
index 0000000000..265a58ce32
--- /dev/null
+++ b/dm/DMComparisonTask.h
@@ -0,0 +1,31 @@
+#ifndef DMComparisonTask_DEFINED
+#define DMComparisonTask_DEFINED
+
+#include "DMTask.h"
+#include "SkBitmap.h"
+#include "SkString.h"
+#include "gm_expectations.h"
+
+namespace DM {
+
+// We use ComparisonTask to move CPU-bound comparison work of GpuTasks back to
+// the main thread pool, where we probably have more threads available.
+
+class ComparisonTask : public Task {
+public:
+    ComparisonTask(const Task& parent, skiagm::Expectations, SkBitmap);
+
+    virtual void draw() SK_OVERRIDE;
+    virtual bool usesGpu() const SK_OVERRIDE { return false; }
+    virtual bool shouldSkip() const SK_OVERRIDE { return false; }
+    virtual SkString name() const SK_OVERRIDE { return fName; }
+
+private:
+    const SkString fName;
+    const skiagm::Expectations fExpectations;
+    const SkBitmap fBitmap;
+};
+
+}  // namespace DM
+
+#endif  // DMComparisonTask_DEFINED
diff --git a/dm/DMCpuTask.cpp b/dm/DMCpuTask.cpp
index 3f51c8a318..1d1d4010f7 100644
--- a/dm/DMCpuTask.cpp
+++ b/dm/DMCpuTask.cpp
@@ -1,9 +1,7 @@
 #include "DMCpuTask.h"
-#include "DMChecksumTask.h"
 #include "DMPipeTask.h"
 #include "DMReplayTask.h"
 #include "DMSerializeTask.h"
-#include "DMTileGridTask.h"
 #include "DMUtil.h"
 #include "DMWriteTask.h"
 
@@ -32,19 +30,19 @@ void CpuTask::draw() {
     fGM->draw(&canvas);
     canvas.flush();
 
-#define SPAWN(ChildTask, ...) this->spawnChild(SkNEW_ARGS(ChildTask, (*this, __VA_ARGS__)))
-    SPAWN(ChecksumTask, fExpectations, bitmap);
+    if (!MeetsExpectations(fExpectations, bitmap)) {
+        this->fail();
+    }
+
+    this->spawnChild(SkNEW_ARGS(PipeTask, (*this, fGMFactory(NULL), bitmap, false, false)));
+    this->spawnChild(SkNEW_ARGS(PipeTask, (*this, fGMFactory(NULL), bitmap, true, false)));
+    this->spawnChild(SkNEW_ARGS(PipeTask, (*this, fGMFactory(NULL), bitmap, true, true)));
 
-    SPAWN(PipeTask, fGMFactory(NULL), bitmap, false, false);
-    SPAWN(PipeTask, fGMFactory(NULL), bitmap, true, false);
-    SPAWN(PipeTask, fGMFactory(NULL), bitmap, true, true);
-    SPAWN(ReplayTask, fGMFactory(NULL), bitmap, false);
-    SPAWN(ReplayTask, fGMFactory(NULL), bitmap, true);
-    SPAWN(SerializeTask, fGMFactory(NULL), bitmap);
-    SPAWN(TileGridTask, fGMFactory(NULL), bitmap, SkISize::Make(16,16));
+    this->spawnChild(SkNEW_ARGS(ReplayTask, (*this, fGMFactory(NULL), bitmap, true)));
+    this->spawnChild(SkNEW_ARGS(ReplayTask, (*this, fGMFactory(NULL), bitmap, false)));
 
-    SPAWN(WriteTask, bitmap);
-#undef SPAWN
+    this->spawnChild(SkNEW_ARGS(SerializeTask, (*this, fGMFactory(NULL), bitmap)));
+    this->spawnChild(SkNEW_ARGS(WriteTask, (*this, bitmap)));
 }
 
 bool CpuTask::shouldSkip() const {
diff --git a/dm/DMGpuTask.cpp b/dm/DMGpuTask.cpp
index d4c4254c62..4d99356237 100644
--- a/dm/DMGpuTask.cpp
+++ b/dm/DMGpuTask.cpp
@@ -1,6 +1,6 @@
 #include "DMGpuTask.h"
 
-#include "DMChecksumTask.h"
+#include "DMComparisonTask.h"
 #include "DMUtil.h"
 #include "DMWriteTask.h"
 #include "SkCommandLineFlags.h"
@@ -60,7 +60,9 @@ void GpuTask::draw() {
     gr->printCacheStats();
 #endif
 
-    this->spawnChild(SkNEW_ARGS(ChecksumTask, (*this, fExpectations, bitmap)));
+    // We offload checksum comparison to the main CPU threadpool.
+    // This cuts run time by about 30%.
+    this->spawnChild(SkNEW_ARGS(ComparisonTask, (*this, fExpectations, bitmap)));
     this->spawnChild(SkNEW_ARGS(WriteTask, (*this, bitmap)));
 }
 
diff --git a/dm/DMPipeTask.cpp b/dm/DMPipeTask.cpp
index de3897a898..8a8fe62000 100644
--- a/dm/DMPipeTask.cpp
+++ b/dm/DMPipeTask.cpp
@@ -6,7 +6,7 @@
 #include "SkCommandLineFlags.h"
 #include "SkGPipe.h"
 
-DEFINE_bool(pipe, true, "If true, check several pipe variants against the reference bitmap.");
+DEFINE_bool(pipe, false, "If true, check several pipe variants against the reference bitmap.");
 
 namespace DM {
 
diff --git a/dm/DMReplayTask.cpp b/dm/DMReplayTask.cpp
index af8669b7d1..0ec9e250d9 100644
--- a/dm/DMReplayTask.cpp
+++ b/dm/DMReplayTask.cpp
@@ -5,8 +5,8 @@
 #include "SkCommandLineFlags.h"
 #include "SkPicture.h"
 
-DEFINE_bool(replay, true, "If true, run picture replay tests.");
-DEFINE_bool(rtree,  true, "If true, run picture replay tests with an rtree.");
+DEFINE_bool(replay, false, "If true, run picture replay tests.");
+DEFINE_bool(rtree,  false, "If true, run picture replay tests with an rtree.");
 
 namespace DM {
 
diff --git a/dm/DMReplayTask.h b/dm/DMReplayTask.h
index 1245009923..1217c07396 100644
--- a/dm/DMReplayTask.h
+++ b/dm/DMReplayTask.h
@@ -15,8 +15,8 @@ class ReplayTask : public Task {
 
 public:
     ReplayTask(const Task& parent,  // ReplayTask must be a child task.  Pass its parent here.
-               skiagm::GM*,         // GM to run through a picture.  Takes ownership.
-               SkBitmap reference,  // Bitmap to compare picture replay results to.
+               skiagm::GM*,         // GM to run through a pipe.  Takes ownership.
+               SkBitmap reference,  // Bitmap to compare pipe results to.
                bool useRTree);      // Record with an RTree?
 
     virtual void draw() SK_OVERRIDE;
diff --git a/dm/DMReporter.cpp b/dm/DMReporter.cpp
index 31310d1cd9..0e01d71f20 100644
--- a/dm/DMReporter.cpp
+++ b/dm/DMReporter.cpp
@@ -12,7 +12,7 @@ void Reporter::updateStatusLine() const {
     }
 
     SkString status;
-    status.printf("\r\033[K%d tasks left", this->started() - this->finished());
+    status.printf("\r\033[K%d / %d", this->finished(), this->started());
     const int failed = this->failed();
     if (failed > 0) {
         status.appendf(", %d failed", failed);
diff --git a/dm/DMSerializeTask.cpp b/dm/DMSerializeTask.cpp
index 8bc8c8ef98..d71dfdccfa 100644
--- a/dm/DMSerializeTask.cpp
+++ b/dm/DMSerializeTask.cpp
@@ -6,7 +6,7 @@
 #include "SkPicture.h"
 #include "SkPixelRef.h"
 
-DEFINE_bool(serialize, true, "If true, run picture serialization tests.");
+DEFINE_bool(serialize, false, "If true, run picture serialization tests.");
 
 namespace DM {
 
diff --git a/dm/DMTask.cpp b/dm/DMTask.cpp
index a5c75f0f8a..ba74a5f409 100644
--- a/dm/DMTask.cpp
+++ b/dm/DMTask.cpp
@@ -8,15 +8,14 @@
 namespace DM {
 
 Task::Task(Reporter* reporter, TaskRunner* taskRunner)
-    : fReporter(reporter), fTaskRunner(taskRunner), fDepth(0) {
+    : fReporter(reporter), fTaskRunner(taskRunner) {
     fReporter->start();
 }
 
-Task::Task(const Task& parent)
-    : INHERITED(parent)
-    , fReporter(parent.fReporter)
-    , fTaskRunner(parent.fTaskRunner)
-    , fDepth(parent.depth()+1) {
+Task::Task(const Task& that)
+    : INHERITED(that)
+    , fReporter(that.fReporter)
+    , fTaskRunner(that.fTaskRunner) {
     fReporter->start();
 }
 
diff --git a/dm/DMTask.h b/dm/DMTask.h
index 0d3ef74cc3..5388196ffd 100644
--- a/dm/DMTask.h
+++ b/dm/DMTask.h
@@ -18,7 +18,7 @@ class TaskRunner;
 class Task : public SkRunnable {
 public:
     Task(Reporter* reporter, TaskRunner* taskRunner);
-    Task(const Task& parent);
+    Task(const Task& that);
     virtual ~Task();
 
     void run() SK_OVERRIDE;
@@ -28,10 +28,6 @@ public:
     virtual bool shouldSkip() const = 0;
     virtual SkString name() const = 0;
 
-    // Returns the number of parents above this task.
-    // Top-level tasks return 0, their children 1, and so on.
-    int depth() const { return fDepth; }
-
 protected:
     void spawnChild(Task* task);
     void fail();
@@ -40,7 +36,6 @@ private:
     // Both unowned.
     Reporter* fReporter;
     TaskRunner* fTaskRunner;
-    int fDepth;
 
     typedef SkRunnable INHERITED;
 };
diff --git a/dm/DMUtil.cpp b/dm/DMUtil.cpp
index 6cf6c22e2a..d5214849e6 100644
--- a/dm/DMUtil.cpp
+++ b/dm/DMUtil.cpp
@@ -15,9 +15,18 @@ SkString Png(SkString s) {
     return s;
 }
 
+bool MeetsExpectations(const skiagm::Expectations& expectations, const SkBitmap bitmap) {
+    if (expectations.ignoreFailure() || expectations.empty()) {
+        return true;
+    }
+    const skiagm::GmResultDigest digest(bitmap);
+    return expectations.match(digest);
+}
+
 void RecordPicture(skiagm::GM* gm, SkPicture* picture, uint32_t recordFlags) {
-    const SkISize size = gm->getISize();
-    SkCanvas* canvas = picture->beginRecording(size.width(), size.height(), recordFlags);
+    SkCanvas* canvas = picture->beginRecording(SkScalarCeilToInt(gm->width()),
+                                               SkScalarCeilToInt(gm->height()),
+                                               recordFlags);
     canvas->concat(gm->getInitialTransform());
     gm->draw(canvas);
     canvas->flush();
@@ -25,8 +34,7 @@ void RecordPicture(skiagm::GM* gm, SkPicture* picture, uint32_t recordFlags) {
 }
 
 void SetupBitmap(const SkBitmap::Config config, skiagm::GM* gm, SkBitmap* bitmap) {
-    const SkISize size = gm->getISize();
-    bitmap->setConfig(config, size.width(), size.height());
+    bitmap->setConfig(config, SkScalarCeilToInt(gm->width()), SkScalarCeilToInt(gm->height()));
     bitmap->allocPixels();
     bitmap->eraseColor(0x00000000);
 }
diff --git a/dm/DMUtil.h b/dm/DMUtil.h
index 5f22df0878..512ad64eb6 100644
--- a/dm/DMUtil.h
+++ b/dm/DMUtil.h
@@ -15,6 +15,9 @@ SkString UnderJoin(const char* a, const char* b);
 // Png("a") -> "a.png"
 SkString Png(SkString s);
 
+// Roughly, expectations.match(GmResultDigest(bitmap)), but calculates the digest lazily.
+bool MeetsExpectations(const skiagm::Expectations& expectations, const SkBitmap bitmap);
+
 // Draw gm to picture.  Passes recordFlags to SkPicture::beginRecording().
 void RecordPicture(skiagm::GM* gm, SkPicture* picture, uint32_t recordFlags = 0);
 
diff --git a/dm/DMWriteTask.cpp b/dm/DMWriteTask.cpp
index c86381f78a..011b339540 100644
--- a/dm/DMWriteTask.cpp
+++ b/dm/DMWriteTask.cpp
@@ -3,54 +3,41 @@
 #include "DMUtil.h"
 #include "SkCommandLineFlags.h"
 #include "SkImageEncoder.h"
-#include "SkString.h"
+
+#include <string.h>
 
 DEFINE_string2(writePath, w, "", "If set, write GMs here as .pngs.");
 
 namespace DM {
 
-WriteTask::WriteTask(const Task& parent, SkBitmap bitmap) : Task(parent), fBitmap(bitmap) {
-    const int suffixes = parent.depth() + 1;
-    const char* name = parent.name().c_str();
-    SkTArray<SkString> split;
-    SkStrSplit(name, "_", &split);
-    int totalSuffixLength = 0;
-    for (int i = 0; i < suffixes; i++) {
-        // We're splitting off suffixes from the back to front.
-        fSuffixes.push_back(split[split.count()-i-1]);
-        totalSuffixLength += fSuffixes.back().size() + 1;
-    }
-    fGmName.set(name, strlen(name)-totalSuffixLength);
-}
+WriteTask::WriteTask(const Task& parent, SkBitmap bitmap)
+    : Task(parent)
+    , fBitmap(bitmap) {
+    // Split parent's name <gmName>_<config> into gmName and config.
+    const char* parentName = parent.name().c_str();
+    const char* fromLastUnderscore = strrchr(parentName, '_');
+    const ptrdiff_t gmNameLength = fromLastUnderscore - parentName;
 
-void WriteTask::makeDirOrFail(SkString dir) {
-    if (!sk_mkdir(dir.c_str())) {
-        this->fail();
-    }
+    fConfig.set(fromLastUnderscore+1);
+    fGmName.set(parentName, gmNameLength);
 }
 
 void WriteTask::draw() {
-    SkString dir(FLAGS_writePath[0]);
-    this->makeDirOrFail(dir);
-    for (int i = 0; i < fSuffixes.count(); i++) {
-        dir = SkOSPath::SkPathJoin(dir.c_str(), fSuffixes[i].c_str());
-        this->makeDirOrFail(dir);
-    }
-    if (!SkImageEncoder::EncodeFile(Png(SkOSPath::SkPathJoin(dir.c_str(), fGmName.c_str())).c_str(),
+    const char* root = FLAGS_writePath[0];
+    const SkString dir = SkOSPath::SkPathJoin(root, fConfig.c_str());
+    if (!sk_mkdir(root) ||
+        !sk_mkdir(dir.c_str())  ||
+        !SkImageEncoder::EncodeFile(Png(SkOSPath::SkPathJoin(dir.c_str(), fGmName.c_str())).c_str(),
                                     fBitmap,
                                     SkImageEncoder::kPNG_Type,
-                                    100/*quality*/)) {
+                                    100/*quality*/))
+    {
         this->fail();
     }
 }
 
 SkString WriteTask::name() const {
-    SkString name("writing ");
-    for (int i = 0; i < fSuffixes.count(); i++) {
-        name.appendf("%s/", fSuffixes[i].c_str());
-    }
-    name.append(fGmName.c_str());
-    return name;
+    return SkStringPrintf("writing %s/%s.png", fConfig.c_str(), fGmName.c_str());
 }
 
 bool WriteTask::shouldSkip() const {
diff --git a/dm/DMWriteTask.h b/dm/DMWriteTask.h
index 82a26bc928..7a9b4faf8a 100644
--- a/dm/DMWriteTask.h
+++ b/dm/DMWriteTask.h
@@ -4,7 +4,6 @@
 #include "DMTask.h"
 #include "SkBitmap.h"
 #include "SkString.h"
-#include "SkTArray.h"
 
 // Writes a bitmap to a file.
 
@@ -13,8 +12,7 @@ namespace DM {
 class WriteTask : public Task {
 
 public:
-    WriteTask(const Task& parent,  // WriteTask must be a child Task.  Pass its parent here.
-              SkBitmap bitmap);    // Bitmap to write.
+    WriteTask(const Task& parent, SkBitmap bitmap);
 
     virtual void draw() SK_OVERRIDE;
     virtual bool usesGpu() const SK_OVERRIDE { return false; }
@@ -22,11 +20,9 @@ public:
     virtual SkString name() const SK_OVERRIDE;
 
 private:
-    SkTArray<SkString> fSuffixes;
+    SkString fConfig;
     SkString fGmName;
     const SkBitmap fBitmap;
-
-    void makeDirOrFail(SkString dir);
 };
 
 }  // namespace DM
diff --git a/dm/README b/dm/README
index 78b962e40f..6cde6867ab 100644
--- a/dm/README
+++ b/dm/README
@@ -7,6 +7,7 @@ Current approximate list of missing features:
   --writePicturePath
 
   --deferred
+  --tiledGrid
 
 
 DM's design is based around Tasks and a TaskRunner.