Remove unnamed namespace usage from tests/

Skia preference is to use 'static' keyword rather than use unnamed
namespace.

BUG=None
TEST=tests
R=robertphillips@google.com, bsalomon@google.com

Review URL: https://codereview.chromium.org/132403008

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

6 files changed, 122 insertions, 145 deletions

diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index 8a329d8838..9ac5f81392 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -166,8 +166,6 @@ DEF_TEST(DecodingImageGenerator, reporter) {
     test_three_encodings(reporter, install_skDiscardablePixelRef);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-namespace {
 class TestImageGenerator : public SkImageGenerator {
 public:
     enum TestType {
@@ -183,8 +181,8 @@ public:
         : fType(type), fReporter(reporter) {
         SkASSERT((fType <= kLast_TestType) && (fType >= 0));
     }
-    ~TestImageGenerator() { }
-    bool getInfo(SkImageInfo* info) SK_OVERRIDE {
+    virtual ~TestImageGenerator() { }
+    virtual bool getInfo(SkImageInfo* info) SK_OVERRIDE {
         REPORTER_ASSERT(fReporter, NULL != info);
         if ((NULL == info) || (kFailGetInfo_TestType == fType)) {
             return false;
@@ -195,9 +193,9 @@ public:
         info->fAlphaType = kOpaque_SkAlphaType;
         return true;
     }
-    bool getPixels(const SkImageInfo& info,
-                   void* pixels,
-                   size_t rowBytes) SK_OVERRIDE {
+    virtual bool getPixels(const SkImageInfo& info,
+                           void* pixels,
+                           size_t rowBytes) SK_OVERRIDE {
         REPORTER_ASSERT(fReporter, pixels != NULL);
         size_t minRowBytes
             = static_cast<size_t>(info.fWidth * info.bytesPerPixel());
@@ -221,8 +219,8 @@ private:
     skiatest::Reporter* const fReporter;
 };
 
-void CheckTestImageGeneratorBitmap(skiatest::Reporter* reporter,
-                                   const SkBitmap& bm) {
+static void check_test_image_generator_bitmap(skiatest::Reporter* reporter,
+                                              const SkBitmap& bm) {
     REPORTER_ASSERT(reporter, TestImageGenerator::Width() == bm.width());
     REPORTER_ASSERT(reporter, TestImageGenerator::Height() == bm.height());
     SkAutoLockPixels autoLockPixels(bm);
@@ -246,10 +244,11 @@ enum PixelRefType {
     kSkDiscardable_PixelRefType,
     kLast_PixelRefType = kSkDiscardable_PixelRefType
 };
-void CheckPixelRef(TestImageGenerator::TestType type,
-                   skiatest::Reporter* reporter,
-                   PixelRefType pixelRefType,
-                   SkDiscardableMemory::Factory* factory) {
+
+static void check_pixelref(TestImageGenerator::TestType type,
+                           skiatest::Reporter* reporter,
+                           PixelRefType pixelRefType,
+                           SkDiscardableMemory::Factory* factory) {
     SkASSERT((pixelRefType >= 0) && (pixelRefType <= kLast_PixelRefType));
     SkAutoTDelete<SkImageGenerator> gen(SkNEW_ARGS(TestImageGenerator,
                                                    (type, reporter)));
@@ -265,20 +264,18 @@ void CheckPixelRef(TestImageGenerator::TestType type,
     REPORTER_ASSERT(reporter, success
                     == (TestImageGenerator::kFailGetInfo_TestType != type));
     if (TestImageGenerator::kSucceedGetPixels_TestType == type) {
-        CheckTestImageGeneratorBitmap(reporter, lazy);
+        check_test_image_generator_bitmap(reporter, lazy);
     } else if (TestImageGenerator::kFailGetPixels_TestType == type) {
         SkAutoLockPixels autoLockPixels(lazy);
         REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
     }
 }
-}  // namespace
 
 // new/lock/delete is an odd pattern for a pixelref, but it needs to not assert
 static void test_newlockdelete(skiatest::Reporter* reporter) {
     SkBitmap bm;
     SkImageGenerator* ig = new TestImageGenerator(
-                                 TestImageGenerator::kSucceedGetPixels_TestType,
-                                 reporter);
+        TestImageGenerator::kSucceedGetPixels_TestType, reporter);
     SkInstallDiscardablePixelRef(ig, &bm, NULL);
     bm.pixelRef()->lockPixels();
 }
@@ -291,37 +288,36 @@ static void test_newlockdelete(skiatest::Reporter* reporter) {
 DEF_TEST(DiscardableAndCachingPixelRef, reporter) {
     test_newlockdelete(reporter);
 
-    CheckPixelRef(TestImageGenerator::kFailGetInfo_TestType,
-                  reporter, kSkCaching_PixelRefType, NULL);
-    CheckPixelRef(TestImageGenerator::kFailGetPixels_TestType,
-                  reporter, kSkCaching_PixelRefType, NULL);
-    CheckPixelRef(TestImageGenerator::kSucceedGetPixels_TestType,
-                  reporter, kSkCaching_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kFailGetInfo_TestType,
+                   reporter, kSkCaching_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
+                   reporter, kSkCaching_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
+                   reporter, kSkCaching_PixelRefType, NULL);
 
-    CheckPixelRef(TestImageGenerator::kFailGetInfo_TestType,
-                  reporter, kSkDiscardable_PixelRefType, NULL);
-    CheckPixelRef(TestImageGenerator::kFailGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, NULL);
-    CheckPixelRef(TestImageGenerator::kSucceedGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kFailGetInfo_TestType,
+                   reporter, kSkDiscardable_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, NULL);
+    check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, NULL);
 
     SkAutoTUnref<SkDiscardableMemoryPool> pool(
         SkNEW_ARGS(SkDiscardableMemoryPool, (1, NULL)));
     REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
-    CheckPixelRef(TestImageGenerator::kFailGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, pool);
+    check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, pool);
     REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
-    CheckPixelRef(TestImageGenerator::kSucceedGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, pool);
+    check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, pool);
     REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed());
 
     SkDiscardableMemoryPool* globalPool = SkGetGlobalDiscardableMemoryPool();
     // Only acts differently from NULL on a platform that has a
     // default discardable memory implementation that differs from the
     // global DM pool.
-    CheckPixelRef(TestImageGenerator::kFailGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, globalPool);
-    CheckPixelRef(TestImageGenerator::kSucceedGetPixels_TestType,
-                  reporter, kSkDiscardable_PixelRefType, globalPool);
+    check_pixelref(TestImageGenerator::kFailGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, globalPool);
+    check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType,
+                   reporter, kSkDiscardable_PixelRefType, globalPool);
 }
-////////////////////////////////////////////////////////////////////////////////
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index a6ab817c44..2b5e420bd0 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -17,13 +17,12 @@
 #include "SkRandom.h"
 #include "SkMatrixUtils.h"
 
-namespace {
 // A BitmapFactory that always fails when asked to return pixels.
 class FailureImageGenerator : public SkImageGenerator {
 public:
     FailureImageGenerator() { }
     virtual ~FailureImageGenerator() { }
-    virtual bool getInfo(SkImageInfo* info) {
+    virtual bool getInfo(SkImageInfo* info) SK_OVERRIDE {
         info->fWidth = 100;
         info->fHeight = 100;
         info->fColorType = kPMColor_SkColorType;
@@ -38,7 +37,6 @@ public:
         return false;
     }
 };
-}  // namespace
 
 // crbug.com/295895
 // Crashing in skia when a pixelref fails in lockPixels
diff --git a/tests/GifTest.cpp b/tests/GifTest.cpp
index c2b8a88032..7d5d56cc13 100644
--- a/tests/GifTest.cpp
+++ b/tests/GifTest.cpp
@@ -21,43 +21,36 @@
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
-namespace {
-    unsigned char gifData[] = {
-        0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x03, 0x00,
-        0x03, 0x00, 0xe3, 0x08, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00,
-        0xff, 0x80, 0x80, 0x80, 0x00, 0xff, 0x00, 0x00,
-        0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00,
-        0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x04,
-        0x07, 0x50, 0x1c, 0x43, 0x40, 0x41, 0x23, 0x44,
-        0x00, 0x3b};
-    unsigned char gifDataNoColormap[] = {
-        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00,
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04,
-        0x01, 0x0a, 0x00, 0x01, 0x00, 0x2c, 0x00, 0x00,
-        0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02,
-        0x02, 0x4c, 0x01, 0x00, 0x3b};
-    unsigned char interlacedGif[] = {
-        0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x09, 0x00,
-        0x09, 0x00, 0xe3, 0x08, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00,
-        0xff, 0x80, 0x80, 0x80, 0x00, 0xff, 0x00, 0x00,
-        0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-        0xff, 0xff, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00,
-        0x00, 0x00, 0x09, 0x00, 0x09, 0x00, 0x40, 0x04,
-        0x1b, 0x50, 0x1c, 0x23, 0xe9, 0x44, 0x23, 0x60,
-        0x9d, 0x09, 0x28, 0x1e, 0xf8, 0x6d, 0x64, 0x56,
-        0x9d, 0x53, 0xa8, 0x7e, 0xa8, 0x65, 0x94, 0x5c,
-        0xb0, 0x8a, 0x45, 0x04, 0x00, 0x3b};
-};  // namespace
+static unsigned char gGIFData[] = {
+  0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x03, 0x00, 0x03, 0x00, 0xe3, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00,
+  0xff, 0x80, 0x80, 0x80, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x04,
+  0x07, 0x50, 0x1c, 0x43, 0x40, 0x41, 0x23, 0x44, 0x00, 0x3b
+};
+
+static unsigned char gGIFDataNoColormap[] = {
+  0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x21, 0xf9, 0x04, 0x01, 0x0a, 0x00, 0x01, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x4c, 0x01, 0x00, 0x3b
+};
+
+static unsigned char gInterlacedGIF[] = {
+  0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x09, 0x00, 0x09, 0x00, 0xe3, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x80,
+  0x80, 0x80, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00,
+  0x00, 0x09, 0x00, 0x09, 0x00, 0x40, 0x04, 0x1b, 0x50, 0x1c, 0x23, 0xe9, 0x44,
+  0x23, 0x60, 0x9d, 0x09, 0x28, 0x1e, 0xf8, 0x6d, 0x64, 0x56, 0x9d, 0x53, 0xa8,
+  0x7e, 0xa8, 0x65, 0x94, 0x5c, 0xb0, 0x8a, 0x45, 0x04, 0x00, 0x3b
+};
 
 static void test_gif_data_no_colormap(skiatest::Reporter* r,
-                                  void* data, size_t size) {
+                                      void* data,
+                                      size_t size) {
     SkBitmap bm;
     bool imageDecodeSuccess = SkImageDecoder::DecodeMemory(
         data, size, &bm);
@@ -149,57 +142,57 @@ static void test_gif_data_short(skiatest::Reporter* r,
 */
 DEF_TEST(Gif, reporter) {
     // test perfectly good images.
-    test_gif_data(reporter, static_cast<void *>(gifData), sizeof(gifData));
-    test_interlaced_gif_data(reporter, static_cast<void *>(interlacedGif),
-                          sizeof(interlacedGif));
+    test_gif_data(reporter, static_cast<void *>(gGIFData), sizeof(gGIFData));
+    test_interlaced_gif_data(reporter, static_cast<void *>(gInterlacedGIF),
+                          sizeof(gInterlacedGIF));
 
-    unsigned char badData[sizeof(gifData)];
+    unsigned char badData[sizeof(gGIFData)];
 
     /* If you set the environment variable
        skia_images_gif_suppressDecoderWarnings to 'false', you will
        see warnings on stderr.  This is a feature.  */
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[6] = 0x01;  // image too wide
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [image too wide, expanding output to size]"
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[8] = 0x01;  // image too tall
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [image too tall,  expanding output to size]"
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[62] = 0x01;  // image shifted right
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [shifting image left to fit]"
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[64] = 0x01;  // image shifted down
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [shifting image up to fit]"
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[62] = 0xff;  // image shifted left
     badData[63] = 0xff;  // 2's complement -1 short
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [shifting image left to fit]"
 
-    memcpy(badData, gifData, sizeof(gifData));
+    memcpy(badData, gGIFData, sizeof(gGIFData));
     badData[64] = 0xff;  // image shifted up
     badData[65] = 0xff;  // 2's complement -1 short
-    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gifData));
+    test_gif_data(reporter, static_cast<void *>(badData), sizeof(gGIFData));
     // "libgif warning [shifting image up to fit]"
 
-    test_gif_data_no_colormap(reporter, static_cast<void *>(gifDataNoColormap),
-                              sizeof(gifDataNoColormap));
+    test_gif_data_no_colormap(reporter, static_cast<void *>(gGIFDataNoColormap),
+                              sizeof(gGIFDataNoColormap));
     // "libgif warning [missing colormap]"
 
     // test short Gif.  80 is missing a few bytes.
-    test_gif_data_short(reporter, static_cast<void *>(gifData), 80);
+    test_gif_data_short(reporter, static_cast<void *>(gGIFData), 80);
     // "libgif warning [DGifGetLine]"
 
-    test_interlaced_gif_data(reporter, static_cast<void *>(interlacedGif),
+    test_interlaced_gif_data(reporter, static_cast<void *>(gInterlacedGIF),
                              100);  // 100 is missing a few bytes
     // "libgif warning [interlace DGifGetLine]"
 }
diff --git a/tests/ImageDecodingTest.cpp b/tests/ImageDecodingTest.cpp
index b4aaa9c5a2..57990a520e 100644
--- a/tests/ImageDecodingTest.cpp
+++ b/tests/ImageDecodingTest.cpp
@@ -240,12 +240,10 @@ DEF_TEST(ImageDecoding, reporter) {
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-namespace {
 // expected output for 8x8 bitmap
-const int kExpectedWidth = 8;
-const int kExpectedHeight = 8;
-const SkColor kExpectedPixels[] = {
+static const int kExpectedWidth = 8;
+static const int kExpectedHeight = 8;
+static const SkColor kExpectedPixels[] = {
     0xffbba570, 0xff395f5d, 0xffe25c39, 0xff197666,
     0xff3cba27, 0xffdefcb0, 0xffc13874, 0xfffa0093,
     0xffbda60e, 0xffc01db6, 0xff2bd688, 0xff9362d4,
@@ -265,7 +263,6 @@ const SkColor kExpectedPixels[] = {
 };
 SK_COMPILE_ASSERT((kExpectedWidth * kExpectedHeight)
                   == SK_ARRAY_COUNT(kExpectedPixels), array_size_mismatch);
-}  // namespace
 
 DEF_TEST(WebP, reporter) {
     const unsigned char encodedWebP[] = {
@@ -582,4 +579,3 @@ DEF_TEST(ImageDecoderOptions, reporter) {
         }
     }
 }
-////////////////////////////////////////////////////////////////////////////////
diff --git a/tests/PixelRefTest.cpp b/tests/PixelRefTest.cpp
index d7fe9f47aa..1e9bbe7a3b 100644
--- a/tests/PixelRefTest.cpp
+++ b/tests/PixelRefTest.cpp
@@ -37,18 +37,14 @@ static void test_info(skiatest::Reporter* reporter) {
     }
 }
 
-namespace {
-
 class TestListener : public SkPixelRef::GenIDChangeListener {
 public:
     explicit TestListener(int* ptr) : fPtr(ptr) {}
-    void onChange() SK_OVERRIDE { (*fPtr)++; }
+    virtual void onChange() SK_OVERRIDE { (*fPtr)++; }
 private:
     int* fPtr;
 };
 
-}  // namespace
-
 DEF_TEST(PixelRef_GenIDChange, r) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
 
diff --git a/tests/Test.cpp b/tests/Test.cpp
index fe0f7c4a6b..994a342128 100644
--- a/tests/Test.cpp
+++ b/tests/Test.cpp
@@ -56,41 +56,39 @@ const char* Test::getName() {
     return fName.c_str();
 }
 
-namespace {
-    class LocalReporter : public Reporter {
-    public:
-        explicit LocalReporter(Reporter* reporterToMimic) : fReporter(reporterToMimic) {}
-
-        int failure_size() const { return fFailures.count(); }
-        const SkString& failure(int i) const { return fFailures[i]; }
-
-    protected:
-        void onReportFailed(const SkString& desc) SK_OVERRIDE {
-            fFailures.push_back(desc);
-        }
-
-        // Proxy down to fReporter.  We assume these calls are threadsafe.
-        virtual bool allowExtendedTest() const SK_OVERRIDE {
-            return fReporter->allowExtendedTest();
-        }
-
-        virtual bool allowThreaded() const SK_OVERRIDE {
-            return fReporter->allowThreaded();
-        }
-
-        virtual void bumpTestCount() SK_OVERRIDE {
-            fReporter->bumpTestCount();
-        }
-
-        virtual bool verbose() const SK_OVERRIDE {
-            return fReporter->verbose();
-        }
-
-    private:
-        Reporter* fReporter;  // Unowned.
-        SkTArray<SkString> fFailures;
-    };
-}  // namespace
+class LocalReporter : public Reporter {
+public:
+    explicit LocalReporter(Reporter* reporterToMimic) : fReporter(reporterToMimic) {}
+
+    int numFailures() const { return fFailures.count(); }
+    const SkString& failure(int i) const { return fFailures[i]; }
+
+protected:
+    virtual void onReportFailed(const SkString& desc) SK_OVERRIDE {
+        fFailures.push_back(desc);
+    }
+
+    // Proxy down to fReporter.  We assume these calls are threadsafe.
+    virtual bool allowExtendedTest() const SK_OVERRIDE {
+        return fReporter->allowExtendedTest();
+    }
+
+    virtual bool allowThreaded() const SK_OVERRIDE {
+        return fReporter->allowThreaded();
+    }
+
+    virtual void bumpTestCount() SK_OVERRIDE {
+        fReporter->bumpTestCount();
+    }
+
+    virtual bool verbose() const SK_OVERRIDE {
+        return fReporter->verbose();
+    }
+
+private:
+    Reporter* fReporter;  // Unowned.
+    SkTArray<SkString> fFailures;
+};
 
 void Test::run() {
     // Clear the Skia error callback before running any test, to ensure that tests
@@ -105,11 +103,11 @@ void Test::run() {
     // from other tests that might share fReporter.
     LocalReporter local(fReporter);
     this->onRun(&local);
-    fPassed = local.failure_size() == 0;
+    fPassed = local.numFailures() == 0;
     fElapsed = SkTime::GetMSecs() - start;
 
     // Now tell fReporter about any failures and wrap up.
-    for (int i = 0; i < local.failure_size(); i++) {
+    for (int i = 0; i < local.numFailures(); i++) {
       fReporter->reportFailed(local.failure(i));
     }
     fReporter->endTest(this);