clean up more dead code

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 "SkAtomics.h"
 #include "SkCommonFlags.h"
 #include "SkGraphics.h"
 #include "SkOSFile.h"
-#include "SkRunnable.h"
 #include "SkTArray.h"
 #include "SkTaskGroup.h"
 #include "SkTemplates.h"
 #include "SkTime.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #endif
@@ skipping 39 matching lines @@
     int32_t testCount() { return fTestCount; }
     int32_t failCount() { return fFailCount; }
 
 private:
     int32_t fDone;  // atomic
     int32_t fTestCount;  // atomic
     int32_t fFailCount;  // atomic
     const int fTotal;
 };
 
-// Deletes self when run.
-class SkTestRunnable : public SkRunnable {
+class SkTestRunnable {
 public:
     SkTestRunnable(const Test& test,
                    Status* status,
                    GrContextFactory* grContextFactory = nullptr)
         : fTest(test), fStatus(status), fGrContextFactory(grContextFactory) {}
 
-  virtual void run() {
+  void operator()() {
       struct TestReporter : public skiatest::Reporter {
       public:
           TestReporter() : fError(false), fTestCount(0) {}
           void bumpTestCount() override { ++fTestCount; }
           bool allowExtendedTest() const override {
               return FLAGS_extendedTest;
           }
           bool verbose() const override { return FLAGS_veryVerbose; }
           void reportFailed(const skiatest::Failure& failure) override {
               SkDebugf("\nFAILED: %s", failure.toString().c_str());
               fError = true;
           }
           bool fError;
           int fTestCount;
       } reporter;
 
       const SkMSec start = SkTime::GetMSecs();
       fTest.proc(&reporter, fGrContextFactory);
       SkMSec elapsed = SkTime::GetMSecs() - start;
       if (reporter.fError) {
           fStatus->reportFailure();
       }
       fStatus->endTest(fTest.name, !reporter.fError, elapsed,
                        reporter.fTestCount);
-      delete this;
   }
 
 private:
     Test fTest;
     Status* fStatus;
     GrContextFactory* fGrContextFactory;
 };
 
 static bool should_run(const char* testName, bool isGPUTest) {
     if (SkCommandLineFlags::ShouldSkip(FLAGS_match, testName)) {
@@ skipping 64 matching lines @@
 
     Status status(toRun);
     for (const TestRegistry* iter = TestRegistry::Head(); iter;
          iter = iter->next()) {
         const Test& test = iter->factory();
         if (!should_run(test.name, test.needsGpu)) {
             ++skipCount;
         } else if (test.needsGpu) {
             gpuTests.push_back(&test);
         } else {
-            cpuTests.add(new SkTestRunnable(test, &status));
+            cpuTests.add(SkTestRunnable(test, &status));
         }
     }
 
     GrContextFactory* grContextFactoryPtr = nullptr;
 #if SK_SUPPORT_GPU
     // Give GPU tests a context factory if that makes sense on this machine.
     GrContextFactory grContextFactory;
     grContextFactoryPtr = &grContextFactory;
 
 #endif
 
     // Run GPU tests on this thread.
     for (int i = 0; i < gpuTests.count(); i++) {
-        (new SkTestRunnable(*gpuTests[i], &status, grContextFactoryPtr))->run();
+        SkTestRunnable(*gpuTests[i], &status, grContextFactoryPtr)();
     }
 
     // Block until threaded tests finish.
     cpuTests.wait();
 
     if (FLAGS_verbose) {
         SkDebugf(
                 "\nFinished %d tests, %d failures, %d skipped. "
                 "(%d internal tests)",
                 toRun, status.failCount(), skipCount, status.testCount());
         if (gVerboseFinalize) {
             (*gVerboseFinalize)();
         }
     }
 
     SkDebugf("\n");
     return (status.failCount() == 0) ? 0 : 1;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return test_main();
 }
 #endif