Move GPU fences into sk_gpu_test

tools/skpbench/skpbench.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContextFactory.h"
 #include "SkCanvas.h"
 #include "SkOSFile.h"
@@ skipping 15 matching lines @@
  * This is a minimalist program whose sole purpose is to open an skp file, benchmark it on a single
  * config, and exit. It is intended to be used through skpbench.py rather than invoked directly.
  * Limiting the entire process to a single config/skp pair helps to keep the results repeatable.
  *
  * No tiling, looping, or other fanciness is used; it just draws the skp whole into a size-matched
  * render target and syncs the GPU after each draw.
  *
  * Currently, only GPU configs are supported.
  */
 
+using sk_gpu_test::PlatformFence;
+using sk_gpu_test::kInvalidPlatformFence;
+using sk_gpu_test::FenceSync;
+
 DEFINE_int32(duration, 5000, "number of milliseconds to run the benchmark");
 DEFINE_int32(sampleMs, 50, "minimum duration of a sample");
 DEFINE_bool(fps, false, "use fps instead of ms");
 DEFINE_string(skp, "", "path to a single .skp file to benchmark");
 DEFINE_string(png, "", "if set, save a .png proof to disk at this file location");
 DEFINE_int32(verbosity, 4, "level of verbosity (0=none to 5=debug)");
 DEFINE_bool(suppressHeader, false, "don't print a header row before the results");
 
 static const char* header =
     "   accum    median       max       min   stddev  samples  sample_ms  metric  config    bench";
 
 static const char* resultFormat =
     "%8.4g  %8.4g  %8.4g  %8.4g  %6.3g%%  %7li  %9i  %-6s  %-9s %s";
 
 struct Sample {
     using clock = std::chrono::high_resolution_clock;
 
     Sample() : fFrames(0), fDuration(0) {}
     double seconds() const { return std::chrono::duration<double>(fDuration).count(); }
     double ms() const { return std::chrono::duration<double, std::milli>(fDuration).count(); }
     double value() const { return FLAGS_fps ? fFrames / this->seconds() : this->ms() / fFrames; }
     static const char* metric() { return FLAGS_fps ? "fps" : "ms"; }
 
     int fFrames;
     clock::duration fDuration;
 };
 
 class GpuSync {
 public:
-    GpuSync(const SkGpuFenceSync* fenceSync);
+    GpuSync(const FenceSync* fenceSync);
     ~GpuSync();
 
     void syncToPreviousFrame();
 
 private:
     void updateFence();
 
-    const SkGpuFenceSync* const   fFenceSync;
-    SkPlatformGpuFence            fFence;
+    const FenceSync* const   fFenceSync;
+    PlatformFence            fFence;
 };
 
 enum class ExitErr {
     kOk           = 0,
     kUsage        = 64,
     kData         = 65,
     kUnavailable  = 69,
     kIO           = 74,
     kSoftware     = 70
 };
 
 static void draw_skp_and_flush(SkCanvas*, const SkPicture*);
 static bool mkdir_p(const SkString& name);
 static SkString join(const SkCommandLineFlags::StringArray&);
 static void exitf(ExitErr, const char* format, ...);
 
-static void run_benchmark(const SkGpuFenceSync* fenceSync, SkCanvas* canvas, const SkPicture* skp,
+static void run_benchmark(const FenceSync* fenceSync, SkCanvas* canvas, const SkPicture* skp,
                           std::vector<Sample>* samples) {
     using clock = Sample::clock;
     const clock::duration sampleDuration = std::chrono::milliseconds(FLAGS_sampleMs);
     const clock::duration benchDuration = std::chrono::milliseconds(FLAGS_duration);
 
     draw_skp_and_flush(canvas, skp);
     GpuSync gpuSync(fenceSync);
 
     draw_skp_and_flush(canvas, skp);
     gpuSync.syncToPreviousFrame();
@@ skipping 187 matching lines @@
 static void exitf(ExitErr err, const char* format, ...) {
     fprintf(stderr, ExitErr::kSoftware == err ? "INTERNAL ERROR: " : "ERROR: ");
     va_list args;
     va_start(args, format);
     vfprintf(stderr, format, args);
     va_end(args);
     fprintf(stderr, ExitErr::kSoftware == err ? "; this should never happen.\n": ".\n");
     exit((int)err);
 }
 
-GpuSync::GpuSync(const SkGpuFenceSync* fenceSync)
+GpuSync::GpuSync(const FenceSync* fenceSync)
     : fFenceSync(fenceSync) {
     this->updateFence();
 }
 
 GpuSync::~GpuSync() {
     fFenceSync->deleteFence(fFence);
 }
 
 void GpuSync::syncToPreviousFrame() {
-    if (kInvalidPlatformGpuFence == fFence) {
+    if (kInvalidPlatformFence == fFence) {
         exitf(ExitErr::kSoftware, "attempted to sync with invalid fence");
     }
     if (!fFenceSync->waitFence(fFence)) {
         exitf(ExitErr::kUnavailable, "failed to wait for fence");
     }
     fFenceSync->deleteFence(fFence);
     this->updateFence();
 }
 
 void GpuSync::updateFence() {
     fFence = fFenceSync->insertFence();
-    if (kInvalidPlatformGpuFence == fFence) {
+    if (kInvalidPlatformFence == fFence) {
         exitf(ExitErr::kUnavailable, "failed to insert fence");
     }
 }