Remove unnamed namespace usage from tests/

tests/CachedDecodingPixelRefTest.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 "SkCanvas.h"
 #include "SkData.h"
@@ skipping 149 matching lines @@
 /**
  *  This checks to see that a SkCachingPixelRef and a
  *  SkDiscardablePixelRef works as advertised with a
  *  SkDecodingImageGenerator.
  */
 DEF_TEST(DecodingImageGenerator, reporter) {
     test_three_encodings(reporter, install_skCachingPixelRef);
     test_three_encodings(reporter, install_skDiscardablePixelRef);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-namespace {
 class TestImageGenerator : public SkImageGenerator {
 public:
     enum TestType {
         kFailGetInfo_TestType,
         kFailGetPixels_TestType,
         kSucceedGetPixels_TestType,
         kLast_TestType = kSucceedGetPixels_TestType
     };
     static int Width() { return 10; }
     static int Height() { return 10; }
     static SkColor Color() { return SK_ColorCYAN; }
     TestImageGenerator(TestType type, skiatest::Reporter* reporter)
         : fType(type), fReporter(reporter) {
         SkASSERT((fType <= kLast_TestType) && (fType >= 0));
     }

[robertphillips, 2014/01/14 13:19:37]

virtual?

[tfarina, 2014/01/21 23:37:43]

Done.

     ~TestImageGenerator() { }

[robertphillips, 2014/01/14 13:19:37]

virtual?

[tfarina, 2014/01/21 23:37:43]

Done.

     bool getInfo(SkImageInfo* info) SK_OVERRIDE {
         REPORTER_ASSERT(fReporter, NULL != info);
         if ((NULL == info) || (kFailGetInfo_TestType == fType)) {
             return false;
         }
         info->fWidth = TestImageGenerator::Width();
         info->fHeight = TestImageGenerator::Height();
         info->fColorType = kPMColor_SkColorType;
         info->fAlphaType = kOpaque_SkAlphaType;
         return true;
     }

[robertphillips, 2014/01/14 13:19:37]

virtual?

[tfarina, 2014/01/21 23:37:43]

Done.

     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());
         REPORTER_ASSERT(fReporter, rowBytes >= minRowBytes);
         if ((NULL == pixels)
             || (fType != kSucceedGetPixels_TestType)
             || (info.fColorType != kPMColor_SkColorType)) {
             return false;
         }
         char* bytePtr = static_cast<char*>(pixels);
         for (int y = 0; y < info.fHeight; ++y) {
             sk_memset32(reinterpret_cast<SkColor*>(bytePtr),
                         TestImageGenerator::Color(), info.fWidth);
             bytePtr += rowBytes;
         }
         return true;
     }
 
 private:
     const TestType fType;
     skiatest::Reporter* const fReporter;
 };
 

[robertphillips, 2014/01/14 13:19:37]

check_test_image_generator_bitmap?

[tfarina, 2014/01/21 23:37:43]

Done.

-void CheckTestImageGeneratorBitmap(skiatest::Reporter* reporter,
-                                   const SkBitmap& bm) {
+static void CheckTestImageGeneratorBitmap(skiatest::Reporter* reporter,
+                                          const SkBitmap& bm) {
     REPORTER_ASSERT(reporter, TestImageGenerator::Width() == bm.width());
     REPORTER_ASSERT(reporter, TestImageGenerator::Height() == bm.height());
     SkAutoLockPixels autoLockPixels(bm);
     REPORTER_ASSERT(reporter, NULL != bm.getPixels());
     if (NULL == bm.getPixels()) {
         return;
     }
     int errors = 0;
     for (int y = 0; y < bm.height(); ++y) {
         for (int x = 0; x < bm.width(); ++x) {
             if (TestImageGenerator::Color() != *bm.getAddr32(x, y)) {
                 ++errors;
             }
         }
     }
     REPORTER_ASSERT(reporter, 0 == errors);
 }
 
 enum PixelRefType {
     kSkCaching_PixelRefType,
     kSkDiscardable_PixelRefType,
     kLast_PixelRefType = kSkDiscardable_PixelRefType
 };
-void CheckPixelRef(TestImageGenerator::TestType type,
-                   skiatest::Reporter* reporter,
-                   PixelRefType pixelRefType,
-                   SkDiscardableMemory::Factory* factory) {
+

[robertphillips, 2014/01/14 13:19:37]

check_pixelref?

[tfarina, 2014/01/21 23:37:43]

Done.

+static void CheckPixelRef(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)));
     REPORTER_ASSERT(reporter, gen.get() != NULL);
     SkBitmap lazy;
     bool success;
     if (kSkCaching_PixelRefType == pixelRefType) {
         // Ignore factory; use global SkScaledImageCache.
         success = SkCachingPixelRef::Install(gen.detach(), &lazy);
     } else {
         success = SkInstallDiscardablePixelRef(gen.detach(), &lazy, factory);
     }
     REPORTER_ASSERT(reporter, success
                     == (TestImageGenerator::kFailGetInfo_TestType != type));
     if (TestImageGenerator::kSucceedGetPixels_TestType == type) {
         CheckTestImageGeneratorBitmap(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();
 }
 
 /**
  *  This tests the basic functionality of SkDiscardablePixelRef with a
  *  basic SkImageGenerator implementation and several
  *  SkDiscardableMemory::Factory choices.
  */
 DEF_TEST(DiscardableAndCachingPixelRef, reporter) {
@@ skipping 25 matching lines @@
 
     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);
 }
-////////////////////////////////////////////////////////////////////////////////