diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp
index a3cd495..3cc03a8 100644
--- a/bench/nanobench.cpp
+++ b/bench/nanobench.cpp
@@ -143,6 +143,7 @@
                      Benchmark* bench,
                      SkCanvas* canvas,
                      double* samples) {
+    gl->makeCurrent();
     // Make sure we're done with whatever came before.
     SK_GL(*gl, Finish());
 
@@ -190,73 +191,138 @@
     return lower;
 }
 
-struct Target {
-    const char* config;
+struct Config {
+    const char* name;
     Benchmark::Backend backend;
+    SkColorType color;
+    SkAlphaType alpha;
+    int samples;
+#if SK_SUPPORT_GPU
+    GrContextFactory::GLContextType ctxType;
+#else
+    int bogusInt;
+#endif
+};
+
+struct Target {
+    explicit Target(const Config& c) : config(c) {}
+    const Config config;
     SkAutoTDelete<SkSurface> surface;
 #if SK_SUPPORT_GPU
     SkGLContextHelper* gl;
 #endif
 };
 
-// If bench is enabled for backend/config, returns a Target* for them, otherwise NULL.
-static Target* is_enabled(Benchmark* bench, Benchmark::Backend backend, const char* config) {
-    if (!bench->isSuitableFor(backend)) {
-        return NULL;
-    }
-
+static bool is_cpu_config_allowed(const char* name) {
     for (int i = 0; i < FLAGS_config.count(); i++) {
-        if (to_lower(FLAGS_config[i]).equals(config)) {
-            Target* target = new Target;
-            target->config  = config;
-            target->backend = backend;
-            return target;
+        if (to_lower(FLAGS_config[i]).equals(name)) {
+            return true;
         }
     }
-    return NULL;
+    return false;
 }
 
-// Append all targets that are suitable for bench.
-static void create_targets(Benchmark* bench, SkTDArray<Target*>* targets) {
-    const int w = bench->getSize().fX,
-              h = bench->getSize().fY;
-    const SkImageInfo _8888 = { w, h, kN32_SkColorType,     kPremul_SkAlphaType },
-                       _565 = { w, h, kRGB_565_SkColorType, kOpaque_SkAlphaType };
+#if SK_SUPPORT_GPU
+static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextType ctxType,
+                                  int sampleCnt) {
+    if (!is_cpu_config_allowed(name)) {
+        return false;
+    }
+    if (const GrContext* ctx = gGrFactory.get(ctxType)) {
+        return sampleCnt <= ctx->getMaxSampleCount();
+    }
+    return false;
+}
+#endif
 
-    #define CPU_TARGET(config, backend, code)                              \
-        if (Target* t = is_enabled(bench, Benchmark::backend, #config)) {  \
-            t->surface.reset(code);                                        \
-            targets->push(t);                                              \
+#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);                                                                \
         }
+         
     if (FLAGS_cpu) {
-        CPU_TARGET(nonrendering, kNonRendering_Backend, NULL)
-        CPU_TARGET(8888, kRaster_Backend, SkSurface::NewRaster(_8888))
-        CPU_TARGET(565,  kRaster_Backend, SkSurface::NewRaster(_565))
+        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_TARGET(config, ctxType, info, samples)                                            \
-        if (Target* t = is_enabled(bench, Benchmark::kGPU_Backend, #config)) {                    \
-            t->surface.reset(SkSurface::NewRenderTarget(gGrFactory.get(ctxType), info, samples)); \
-            t->gl = gGrFactory.getGLContext(ctxType);                                             \
-            targets->push(t);                                                                     \
+    #define GPU_CONFIG(name, ctxType, samples)                                   \
+        if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, samples)) {  \
+            Config config = {                                                    \
+                #name,                                                           \
+                Benchmark::kGPU_Backend,                                         \
+                kN32_SkColorType,                                                \
+                kPremul_SkAlphaType,                                             \
+                samples,                                                         \
+                GrContextFactory::ctxType };                                     \
+            configs->push(config);                                               \
         }
+         
     if (FLAGS_gpu) {
-        GPU_TARGET(gpu,      GrContextFactory::kNative_GLContextType, _8888, 0)
-        GPU_TARGET(msaa4,    GrContextFactory::kNative_GLContextType, _8888, 4)
-        GPU_TARGET(msaa16,   GrContextFactory::kNative_GLContextType, _8888, 16)
-        GPU_TARGET(nvprmsaa4,  GrContextFactory::kNVPR_GLContextType, _8888, 4)
-        GPU_TARGET(nvprmsaa16, GrContextFactory::kNVPR_GLContextType, _8888, 16)
-        GPU_TARGET(debug,     GrContextFactory::kDebug_GLContextType, _8888, 0)
-        GPU_TARGET(nullgpu,    GrContextFactory::kNull_GLContextType, _8888, 0)
-        #if SK_ANGLE
-            GPU_TARGET(angle, GrContextFactory::kANGLE_GLContextType, _8888, 0)
-        #endif
+        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)
     }
 #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;
+    info.fAlphaType = config.alpha;
+    info.fColorType = config.color;
+    info.fWidth = bench->getSize().fX;
+    info.fHeight = bench->getSize().fY;
+
+    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) {
+        target->surface.reset(SkSurface::NewRenderTarget(gGrFactory.get(config.ctxType), info,
+                                                         config.samples));
+        target->gl = gGrFactory.getGLContext(config.ctxType);
+    }
+#endif
+
+    if (Benchmark::kNonRendering_Backend != config.backend && !target->surface.get()) {
+        delete target;
+        return NULL;
+    }
+    return target;
+}
+
+// Creates targets for a benchmark and a set of configs.
+static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
+                           const SkTDArray<Config>& configs) {
+    for (int i = 0; i < configs.count(); ++i) {
+        if (Target* t = is_enabled(b, configs[i])) {
+            targets->push(t);
+        }
+        
+    }
+}
+
 static void fill_static_options(ResultsWriter* log) {
 #if defined(SK_BUILD_FOR_WIN32)
     log->option("system", "WIN32");
@@ -331,6 +397,9 @@
         SkDebugf("loops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
     }
 
+    SkTDArray<Config> configs;
+    create_configs(&configs);
+
     for (const BenchRegistry* r = BenchRegistry::Head(); r != NULL; r = r->next()) {
         SkAutoTDelete<Benchmark> bench(r->factory()(NULL));
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
@@ -338,7 +407,7 @@
         }
 
         SkTDArray<Target*> targets;
-        create_targets(bench.get(), &targets);
+        create_targets(&targets, bench.get(), configs);
 
         if (!targets.isEmpty()) {
             log.bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
@@ -346,11 +415,11 @@
         }
         for (int j = 0; j < targets.count(); j++) {
             SkCanvas* canvas = targets[j]->surface.get() ? targets[j]->surface->getCanvas() : NULL;
-            const char* config = targets[j]->config;
+            const char* config = targets[j]->config.name;
 
             const int loops =
 #if SK_SUPPORT_GPU
-                Benchmark::kGPU_Backend == targets[j]->backend
+                Benchmark::kGPU_Backend == targets[j]->config.backend
                 ? gpu_bench(targets[j]->gl, bench.get(), canvas, samples.get())
                 :
 #endif
@@ -365,7 +434,7 @@
             Stats stats(samples.get(), FLAGS_samples);
             log.config(config);
 #if SK_SUPPORT_GPU
-            if (Benchmark::kGPU_Backend == targets[j]->backend) {
+            if (Benchmark::kGPU_Backend == targets[j]->config.backend) {
                 fill_gpu_options(&log, targets[j]->gl);
             }
 #endif