Get gpudft support working in dm, gm, nanobench and bench_pictures

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "Benchmark.h"
@@ skipping 259 matching lines @@
 }
 
 struct Config {
     const char* name;
     Benchmark::Backend backend;
     SkColorType color;
     SkAlphaType alpha;
     int samples;
 #if SK_SUPPORT_GPU
     GrContextFactory::GLContextType ctxType;
+    bool useDFText;
 #else
     int bogusInt;
+    bool bogusBool;
 #endif
 };
 
 struct Target {
     explicit Target(const Config& c) : config(c) {}
     const Config config;
     SkAutoTDelete<SkSurface> surface;
 #if SK_SUPPORT_GPU
     SkGLContext* gl;
 #endif
@@ skipping 22 matching lines @@
 #endif
 
 #if SK_SUPPORT_GPU
 #define kBogusGLContextType GrContextFactory::kNative_GLContextType
 #else
 #define kBogusGLContextType 0
 #endif
 
 // Append all configs that are enabled and supported.
 static void create_configs(SkTDArray<Config>* configs) {
-    #define CPU_CONFIG(name, backend, color, alpha)                                               \
-        if (is_cpu_config_allowed(#name)) {                                                       \
-            Config config = { #name, Benchmark::backend, color, alpha, 0, kBogusGLContextType };  \
-            configs->push(config);                                                                \
+    #define CPU_CONFIG(name, backend, color, alpha)                       \
+        if (is_cpu_config_allowed(#name)) {                               \
+            Config config = { #name, Benchmark::backend, color, alpha, 0, \
+                              kBogusGLContextType, false };               \
+            configs->push(config);                                        \
         }
 
     if (FLAGS_cpu) {
         CPU_CONFIG(nonrendering, kNonRendering_Backend, kUnknown_SkColorType, kUnpremul_SkAlphaType)
         CPU_CONFIG(8888, kRaster_Backend, kN32_SkColorType, kPremul_SkAlphaType)
         CPU_CONFIG(565, kRaster_Backend, kRGB_565_SkColorType, kOpaque_SkAlphaType)
     }
 
 #if SK_SUPPORT_GPU
-    #define GPU_CONFIG(name, ctxType, samples)                                   \
+    #define GPU_CONFIG(name, ctxType, samples, useDFText)                        \
         if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, samples)) {  \
             Config config = {                                                    \
                 #name,                                                           \
                 Benchmark::kGPU_Backend,                                         \
                 kN32_SkColorType,                                                \
                 kPremul_SkAlphaType,                                             \
                 samples,                                                         \
-                GrContextFactory::ctxType };                                     \
+                GrContextFactory::ctxType,                                       \
+                useDFText };                                                     \
             configs->push(config);                                               \
         }
 
     if (FLAGS_gpu) {
-        GPU_CONFIG(gpu, kNative_GLContextType, 0)
-        GPU_CONFIG(msaa4, kNative_GLContextType, 4)
-        GPU_CONFIG(msaa16, kNative_GLContextType, 16)
-        GPU_CONFIG(nvprmsaa4, kNVPR_GLContextType, 4)
-        GPU_CONFIG(nvprmsaa16, kNVPR_GLContextType, 16)
-        GPU_CONFIG(debug, kDebug_GLContextType, 0)
-        GPU_CONFIG(nullgpu, kNull_GLContextType, 0)
+        GPU_CONFIG(gpu, kNative_GLContextType, 0, false)
+        GPU_CONFIG(msaa4, kNative_GLContextType, 4, false)
+        GPU_CONFIG(msaa16, kNative_GLContextType, 16, false)
+        GPU_CONFIG(nvprmsaa4, kNVPR_GLContextType, 4, false)
+        GPU_CONFIG(nvprmsaa16, kNVPR_GLContextType, 16, false)
+        GPU_CONFIG(gpudft, kNative_GLContextType, 0, true)
+        GPU_CONFIG(debug, kDebug_GLContextType, 0, false)
+        GPU_CONFIG(nullgpu, kNull_GLContextType, 0, false)
 #ifdef SK_ANGLE
-        GPU_CONFIG(angle, kANGLE_GLContextType, 0)
+        GPU_CONFIG(angle, kANGLE_GLContextType, 0, false)
 #endif
     }
 #endif
 }
 
 // If bench is enabled for config, returns a Target* for it, otherwise NULL.
 static Target* is_enabled(Benchmark* bench, const Config& config) {
     if (!bench->isSuitableFor(config.backend)) {
         return NULL;
     }
 
     SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
                                          config.color, config.alpha);
 
     Target* target = new Target(config);
 
     if (Benchmark::kRaster_Backend == config.backend) {
         target->surface.reset(SkSurface::NewRaster(info));
     }
 #if SK_SUPPORT_GPU
     else if (Benchmark::kGPU_Backend == config.backend) {
+        uint32_t flags = config.useDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
+        SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
         target->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(config.ctxType), info,
-                                                         config.samples));
+                                                         config.samples, &props));
         target->gl = gGrFactory->getGLContext(config.ctxType);
     }
 #endif
 
     if (Benchmark::kNonRendering_Backend != config.backend && !target->surface.get()) {
         delete target;
         return NULL;
     }
     return target;
 }
@@ skipping 346 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif