Style Change: SkNEW->new; SkDELETE->delete

tests/PathOpsSkpClipTest.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 "CrashHandler.h"
 // #include "OverwriteLine.h"
 #include "Resources.h"
@@ skipping 282 matching lines @@
 class TestRunnableEncode : public TestRunnableFile {
 public:
     TestRunnableEncode(void (*testFun)(TestState*), int dirNo, const char* name, TestRunner* runner)
         : TestRunnableFile(testFun, dirNo, name, runner) {
         fState.fResult.fTestStep = kEncodeFiles;
     }
 };
 
 TestRunner::~TestRunner() {
     for (int index = 0; index < fRunnables.count(); index++) {
-        SkDELETE(fRunnables[index]);
+        delete fRunnables[index];
     }
 }
 
 void TestRunner::render() {
     // TODO: this doesn't really need to use SkRunnables any more.
     // We can just write the code to run in the for-loop directly.
     sk_parallel_for(fRunnables.count(), [&](int i) {
         fRunnables[i]->run();
     });
 }
@@ skipping 478 matching lines @@
             }
         }
     }
     TestRunner testRunner;
     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.fRunnables.append() = new TestRunnableEncode(&testSkpClipEncode, result.fDirNo,
+                                                                 filename.c_str(), &testRunner);
     }
     testRunner.render();
 }
 
 class Test {
 public:
     Test() {}
     virtual ~Test() {}
 
     const char* getName() { onGetName(&fName); return fName.c_str(); }
     void run() { onRun(); }
 
 protected:
     virtual void onGetName(SkString*) = 0;
     virtual void onRun() = 0;
 
 private:
     SkString    fName;
 };
 
 typedef SkTRegistry<Test*(*)(void*)> TestRegistry;
 
-#define DEF_TEST(name)                                        \
-    static void test_##name();                       \
-    class name##Class : public Test {                                   \
-    public:                                                             \
-        static Test* Factory(void*) { return SkNEW(name##Class); }      \
-    protected:                                                          \
-        void onGetName(SkString* name) override {            \
-            name->set(#name);                                           \
-        }                                                               \
-        void onRun() override { test_##name(); } \
-    };                                                                  \
-    static TestRegistry gReg_##name##Class(name##Class::Factory);       \
+#define DEF_TEST(name)                                                \
+    static void test_##name();                                        \
+    class name##Class : public Test {                                 \
+    public:                                                           \
+        static Test* Factory(void*) { return new name##Class; }       \
+                                                                      \
+    protected:                                                        \
+        void onGetName(SkString* name) override { name->set(#name); } \
+        void onRun() override { test_##name(); }                      \
+    };                                                                \
+    static TestRegistry gReg_##name##Class(name##Class::Factory);     \
     static void test_##name()
 
 DEF_TEST(PathOpsSkpClip) {
     gDirs.setDefault();
     initTest();
     SkTArray<TestResult, true> errors;
     TestState state;
     state.init(0);
     int dirNo;
     gDirs.reset();
@@ skipping 13 matching lines @@
         (void) doOneDir(data, true);
 }
 
 DEF_TEST(PathOpsSkpClipThreaded) {
     gDirs.setDefault();
     initTest();
     TestRunner testRunner;
     int dirNo;
     gDirs.reset();
     while ((dirNo = gDirs.next()) > 0) {
-        *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableDir,
-                (&testSkpClipMain, dirNo, &testRunner));
+        *testRunner.fRunnables.append() = new 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]);
@@ skipping 44 matching lines @@
                     goto checkEarlyExit;
                 }
             }
             {
                 SortByName name;
                 name.init(dirNo);
                 strncpy(name.fFilename, filename.c_str(), filename.size() - 4);  // drop .skp
                 int count = sorted.get()[dirNo - firstDirNo].count();
                 if (SkTSearch<SortByName, Less>(sorted.get()[dirNo - firstDirNo].begin(),
                         count, &name, sizeof(&name)) < 0) {
-                    *testRunner.fRunnables.append() = SkNEW_ARGS(TestRunnableFile,
-                            (&testSkpClip, dirNo, filename.c_str(), &testRunner));
+                    *testRunner.fRunnables.append() = new TestRunnableFile(
+                            &testSkpClip, dirNo, filename.c_str(), &testRunner);
                 }
             }
     checkEarlyExit:
             ;
         }
 
     }
     testRunner.render();
     SkAutoTDeleteArray<SkTDArray<TestResult> > results(new SkTDArray<TestResult>[dirCount]);
     if (!buildTests(results.get(), NULL)) {
@@ skipping 157 matching lines @@
     }
     SkGraphics::Term();
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif