Remove Sk prefix from some bench classes.

bench/benchmain.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 "BenchLogger.h"
 #include "BenchTimer.h"
+#include "Benchmark.h"
 #include "CrashHandler.h"
+#include "GMBench.h"
 #include "ResultsWriter.h"
-#include "SkBenchLogger.h"
-#include "SkBenchmark.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDeferredCanvas.h"
-#include "SkGMBench.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkString.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
@@ skipping 19 matching lines @@
 };
 
 static const char kDefaultsConfigStr[] = "defaults";
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class Iter {
 public:
     Iter() : fBenches(BenchRegistry::Head()), fGMs(skiagm::GMRegistry::Head()) {}
 
-    SkBenchmark* next() {
+    Benchmark* next() {
         if (fBenches) {
             BenchRegistry::Factory f = fBenches->factory();
             fBenches = fBenches->next();
             return (*f)(NULL);
         }
 
         while (fGMs) {
             SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(NULL));
             fGMs = fGMs->next();
             if (gm->getFlags() & skiagm::GM::kAsBench_Flag) {
-                return SkNEW_ARGS(SkGMBench, (gm.detach()));
+                return SkNEW_ARGS(GMBench, (gm.detach()));
             }
         }
 
         return NULL;
     }
 
 private:
     const BenchRegistry* fBenches;
     const skiagm::GMRegistry* fGMs;
 };
@@ skipping 56 matching lines @@
     const SkScalar x = SkIntToScalar(w) / 2;
     const SkScalar y = SkIntToScalar(h) / 2;
 
     canvas->translate(x, y);
     // just enough so we can't take the sprite case
     canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
     canvas->translate(-x, -y);
 }
 
 static SkSurface* make_surface(SkColorType colorType, const SkIPoint& size,
-                               SkBenchmark::Backend backend, int sampleCount,
+                               Benchmark::Backend backend, int sampleCount,
                                GrContext* context) {
     SkSurface* surface = NULL;
     SkImageInfo info = SkImageInfo::Make(size.fX, size.fY, colorType,
                                          kPremul_SkAlphaType);
 
     switch (backend) {
-        case SkBenchmark::kRaster_Backend:
+        case Benchmark::kRaster_Backend:
             surface = SkSurface::NewRaster(info);
             surface->getCanvas()->clear(SK_ColorWHITE);
             break;
 #if SK_SUPPORT_GPU
-        case SkBenchmark::kGPU_Backend: {
+        case Benchmark::kGPU_Backend: {
             surface = SkSurface::NewRenderTarget(context, info, sampleCount);
             break;
         }
 #endif
-        case SkBenchmark::kPDF_Backend:
+        case Benchmark::kPDF_Backend:
         default:
             SkDEBUGFAIL("unsupported");
     }
     return surface;
 }
 
 #if SK_SUPPORT_GPU
 GrContextFactory gContextFactory;
 typedef GrContextFactory::GLContextType GLContextType;
 static const GLContextType kNative = GrContextFactory::kNative_GLContextType;
@@ skipping 11 matching lines @@
 #ifdef SK_DEBUG
 static const bool kIsDebug = true;
 #else
 static const bool kIsDebug = false;
 #endif
 
 static const struct Config {
     SkColorType         fColorType;
     const char*         name;
     int                 sampleCount;
-    SkBenchmark::Backend backend;
+    Benchmark::Backend  backend;
     GLContextType       contextType;
     bool                runByDefault;
 } gConfigs[] = {
-    { kN32_SkColorType,     "NONRENDERING", 0, SkBenchmark::kNonRendering_Backend, kNative, true},
-    { kN32_SkColorType,     "8888",         0, SkBenchmark::kRaster_Backend,       kNative, true},
-    { kRGB_565_SkColorType, "565",          0, SkBenchmark::kRaster_Backend,       kNative, true},
+    { kN32_SkColorType,     "NONRENDERING", 0, Benchmark::kNonRendering_Backend, kNative, true},
+    { kN32_SkColorType,     "8888",         0, Benchmark::kRaster_Backend,       kNative, true},
+    { kRGB_565_SkColorType, "565",          0, Benchmark::kRaster_Backend,       kNative, true},
 #if SK_SUPPORT_GPU
-    { kN32_SkColorType,     "GPU",          0, SkBenchmark::kGPU_Backend,          kNative, true},
-    { kN32_SkColorType,     "MSAA4",        4, SkBenchmark::kGPU_Backend,          kNative, false},
-    { kN32_SkColorType,     "MSAA16",      16, SkBenchmark::kGPU_Backend,          kNative, false},
-    { kN32_SkColorType,     "NVPRMSAA4",    4, SkBenchmark::kGPU_Backend,          kNVPR,   true},
-    { kN32_SkColorType,     "NVPRMSAA16",  16, SkBenchmark::kGPU_Backend,          kNVPR,   false},
+    { kN32_SkColorType,     "GPU",          0, Benchmark::kGPU_Backend,          kNative, true},
+    { kN32_SkColorType,     "MSAA4",        4, Benchmark::kGPU_Backend,          kNative, false},
+    { kN32_SkColorType,     "MSAA16",      16, Benchmark::kGPU_Backend,          kNative, false},
+    { kN32_SkColorType,     "NVPRMSAA4",    4, Benchmark::kGPU_Backend,          kNVPR,   true},
+    { kN32_SkColorType,     "NVPRMSAA16",  16, Benchmark::kGPU_Backend,          kNVPR,   false},
 #if SK_ANGLE
-    { kN32_SkColorType,     "ANGLE",        0, SkBenchmark::kGPU_Backend,          kANGLE,  true},
+    { kN32_SkColorType,     "ANGLE",        0, Benchmark::kGPU_Backend,          kANGLE,  true},
 #endif // SK_ANGLE
-    { kN32_SkColorType,     "Debug",        0, SkBenchmark::kGPU_Backend,          kDebug,  kIsDebug},
-    { kN32_SkColorType,     "NULLGPU",      0, SkBenchmark::kGPU_Backend,          kNull,   true},
+    { kN32_SkColorType,     "Debug",        0, Benchmark::kGPU_Backend,          kDebug,  kIsDebug},
+    { kN32_SkColorType,     "NULLGPU",      0, Benchmark::kGPU_Backend,          kNull,   true},
 #endif // SK_SUPPORT_GPU
 };
 
 DEFINE_string(outDir, "", "If given, image of each bench will be put in outDir.");
 DEFINE_string(timers, "cg", "Timers to display. "
               "Options: w(all) W(all, truncated) c(pu) C(pu, truncated) g(pu)");
 
 DEFINE_bool(rotate, false,  "Rotate canvas before bench run?");
 DEFINE_bool(scale,  false,  "Scale canvas before bench run?");
 DEFINE_bool(clip,   false,  "Clip canvas before bench run?");
@@ skipping 50 matching lines @@
     SetupCrashHandler();
     SkCommandLineFlags::Parse(argc, argv);
 #if SK_ENABLE_INST_COUNT
     if (FLAGS_leaks) {
         gPrintInstCount = true;
     }
 #endif
     SkAutoGraphics ag;
 
     // First, parse some flags.
-    SkBenchLogger logger;
+    BenchLogger logger;
     if (FLAGS_logFile.count()) {
         logger.SetLogFile(FLAGS_logFile[0]);
     }
 
     LoggerResultsWriter logWriter(logger, FLAGS_timeFormat[0]);
     MultiResultsWriter writer;
     writer.add(&logWriter);
 
     SkAutoTDelete<JSONResultsWriter> jsonWriter;
     if (FLAGS_outResultsFile.count()) {
@@ skipping 38 matching lines @@
             if (gConfigs[i].runByDefault) {
                 *configs.append() = i;
             }
         }
     }
     // Filter out things we can't run.
     if (kNormal_BenchMode != benchMode) {
         // Non-rendering configs only run in normal mode
         for (int i = 0; i < configs.count(); ++i) {
             const Config& config = gConfigs[configs[i]];
-            if (SkBenchmark::kNonRendering_Backend == config.backend) {
+            if (Benchmark::kNonRendering_Backend == config.backend) {
                 configs.remove(i, 1);
                 --i;
             }
         }
     }
 
 #if SK_SUPPORT_GPU
     for (int i = 0; i < configs.count(); ++i) {
         const Config& config = gConfigs[configs[i]];
 
-        if (SkBenchmark::kGPU_Backend == config.backend) {
+        if (Benchmark::kGPU_Backend == config.backend) {
             GrContext* context = gContextFactory.get(config.contextType);
             if (NULL == context) {
                 SkDebugf("GrContext could not be created for config %s. Config will be skipped.\n",
                     config.name);
                 configs.remove(i);
                 --i;
                 continue;
             }
             if (config.sampleCount > context->getMaxSampleCount()){
                 SkDebugf(
@@ skipping 37 matching lines @@
 #if defined(SK_DEBUG)
     writer.option("build", "DEBUG");
 #else
     writer.option("build", "RELEASE");
 #endif
 
     // Set texture cache limits if non-default.
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
 #if SK_SUPPORT_GPU
         const Config& config = gConfigs[i];
-        if (SkBenchmark::kGPU_Backend != config.backend) {
+        if (Benchmark::kGPU_Backend != config.backend) {
             continue;
         }
         GrContext* context = gContextFactory.get(config.contextType);
         if (NULL == context) {
             continue;
         }
 
         size_t bytes;
         int count;
         context->getResourceCacheLimits(&count, &bytes);
         if (-1 != FLAGS_gpuCacheBytes) {
             bytes = static_cast<size_t>(FLAGS_gpuCacheBytes);
         }
         if (-1 != FLAGS_gpuCacheCount) {
             count = FLAGS_gpuCacheCount;
         }
         context->setResourceCacheLimits(count, bytes);
 #endif
     }
 
     // Run each bench in each configuration it supports and we asked for.
     Iter iter;
-    SkBenchmark* bench;
+    Benchmark* bench;
     while ((bench = iter.next()) != NULL) {
-        SkAutoTUnref<SkBenchmark> benchUnref(bench);
+        SkAutoTUnref<Benchmark> benchUnref(bench);
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
             continue;
         }
 
         bench->setForceAlpha(alpha);
         bench->setForceAA(FLAGS_forceAA);
         bench->setForceFilter(FLAGS_forceFilter);
         bench->setDither(dither);
         bench->preDraw();
 
         bool loggedBenchName = false;
         for (int i = 0; i < configs.count(); ++i) {
             const int configIndex = configs[i];
             const Config& config = gConfigs[configIndex];
 
             if (!bench->isSuitableFor(config.backend)) {
                 continue;
             }
 
             GrContext* context = NULL;
 #if SK_SUPPORT_GPU
             SkGLContextHelper* glContext = NULL;
-            if (SkBenchmark::kGPU_Backend == config.backend) {
+            if (Benchmark::kGPU_Backend == config.backend) {
                 context = gContextFactory.get(config.contextType);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(config.contextType);
             }
 #endif
 
             SkAutoTUnref<SkCanvas> canvas;
             SkAutoTUnref<SkPicture> recordFrom;
             SkPictureRecorder recorderTo;
             const SkIPoint dim = bench->getSize();
 
             SkAutoTUnref<SkSurface> surface;
-            if (SkBenchmark::kNonRendering_Backend != config.backend) {
+            if (Benchmark::kNonRendering_Backend != config.backend) {
                 surface.reset(make_surface(config.fColorType,
                                            dim,
                                            config.backend,
                                            config.sampleCount,
                                            context));
                 if (!surface.get()) {
                     logger.logError(SkStringPrintf(
                         "Device creation failure for config %s. Will skip.\n", config.name));
                     continue;
                 }
@@ skipping 34 matching lines @@
                 }
             }
 
             if (!loggedBenchName) {
                 loggedBenchName = true;
                 writer.bench(bench->getName(), dim.fX, dim.fY);
             }
 
 #if SK_SUPPORT_GPU
             SkGLContextHelper* contextHelper = NULL;
-            if (SkBenchmark::kGPU_Backend == config.backend) {
+            if (Benchmark::kGPU_Backend == config.backend) {
                 contextHelper = gContextFactory.getGLContext(config.contextType);
             }
             BenchTimer timer(contextHelper);
 #else
             BenchTimer timer;
 #endif
 
             double previous = std::numeric_limits<double>::infinity();
             bool converged = false;
 
@@ skipping 94 matching lines @@
 
                     const double current = timer.fWall / loopsPerIter;
                     if (FLAGS_verbose && current > previous) { SkDebugf("↑"); }
                     if (FLAGS_verbose) { SkDebugf("%.3g ", current); }
                     converged = HasConverged(previous, current, timer.fWall);
                     previous = current;
                 } while (!FLAGS_runOnce && !converged);
             }
             if (FLAGS_verbose) { SkDebugf("\n"); }
 
-            if (!FLAGS_dryRun && FLAGS_outDir.count() && SkBenchmark::kNonRendering_Backend != config.backend) {
+            if (!FLAGS_dryRun && FLAGS_outDir.count() && Benchmark::kNonRendering_Backend != config.backend) {
                 SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
                 if (image.get()) {
                     saveFile(bench->getName(), config.name, FLAGS_outDir[0],
                              image);
                 }
             }
 
             if (FLAGS_runOnce) {
                 // Let's not mislead ourselves by looking at Debug build or single iteration bench times!
                 continue;
@@ skipping 21 matching lines @@
     gContextFactory.destroyContexts();
 #endif
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif