Hey, maybe we should _call_ glFinish.

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 94 matching lines @@
     }
     return loops;
 }
 
 #if SK_SUPPORT_GPU
 static int gpu_bench(SkGLContextHelper* gl,
                      Benchmark* bench,
                      SkCanvas* canvas,
                      double* samples) {
     // Make sure we're done with whatever came before.
-    SK_GL(*gl, Finish);
+    SK_GL(*gl, Finish());
 
     // First, figure out how many loops it'll take to get a frame up to FLAGS_gpuMs.
     int loops = 1;
     double elapsed = 0;
     do {
         loops *= 2;
         // If the GPU lets frames lag at all, we need to make sure we're timing
         // _this_ round, not still timing last round.  We force this by looping
         // more times than any reasonable GPU will allow frames to lag.
         for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
             elapsed = time(loops, bench, canvas, gl);
         }
     } while (elapsed < FLAGS_gpuMs);
 
     // We've overshot at least a little.  Scale back linearly.
     loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
 
     // Might as well make sure we're not still timing our calibration.
-    SK_GL(*gl, Finish);
+    SK_GL(*gl, Finish());
 
     // Pretty much the same deal as the calibration: do some warmup to make
     // sure we're timing steady-state pipelined frames.
     for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
         time(loops, bench, canvas, gl);
     }
 
     // Now, actually do the timing!
     for (int i = 0; i < FLAGS_samples; i++) {
         samples[i] = time(loops, bench, canvas, gl) / loops;
@@ skipping 142 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif