Move SkGLContext and some GrGLInterface implementations to skgputest module

tools/kilobench/kilobench.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 "GrCaps.h"
 #include "GrContextFactory.h"
 #include "Benchmark.h"
 #include "ResultsWriter.h"
 #include "SkCommandLineFlags.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTime.h"
 #include "SkTLList.h"
 #include "SkThreadUtils.h"
 #include "Stats.h"
 #include "Timer.h"
 #include "VisualSKPBench.h"
 #include "gl/GrGLDefines.h"
+#include "gl/GrGLUtil.h"
 #include "../private/SkMutex.h"
 #include "../private/SkSemaphore.h"
 #include "../private/SkGpuFenceSync.h"
 
 // posix only for now
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
+using namespace sk_gpu_test;
+
 /*
  * This is an experimental GPU only benchmarking program.  The initial implementation will only
  * support SKPs.
  */
 
 static const int kAutoTuneLoops = 0;
 
 static const int kDefaultLoops =
 #ifdef SK_DEBUG
     1;
@@ skipping 95 matching lines @@
     }
 
     SkTArray<SkString> fSKPs;
     int fCurrentSKP;
 };
 
 struct GPUTarget {
     void setup() {
         fGL->makeCurrent();
         // Make sure we're done with whatever came before.
-        SK_GL(*fGL, Finish());
+        GR_GL_CALL(fGL->gl(), Finish());
     }
 
     SkCanvas* beginTiming(SkCanvas* canvas) { return canvas; }
 
     void endTiming(bool usePlatformSwapBuffers) {
         if (fGL) {
-            SK_GL(*fGL, Flush());
+            GR_GL_CALL(fGL->gl(), Flush());
             if (usePlatformSwapBuffers) {
                 fGL->swapBuffers();
             } else {
                 fGL->waitOnSyncOrSwap();
             }
         }
     }
     void finish() {
-        SK_GL(*fGL, Finish());
+        GR_GL_CALL(fGL->gl(), Finish());
     }
 
     bool needsFrameTiming(int* maxFrameLag) const {
         if (!fGL->getMaxGpuFrameLag(maxFrameLag)) {
             // Frame lag is unknown.
             *maxFrameLag = FLAGS_gpuFrameLag;
         }
         return true;
     }
 
@@ skipping 34 matching lines @@
             return false;
         }
         bmp->setInfo(canvas->imageInfo());
         if (!canvas->readPixels(bmp, 0, 0)) {
             SkDebugf("Can't read canvas pixels.\n");
             return false;
         }
         return true;
     }
 
-    SkGLContext* gl() { return fGL; }
+    GLContext* gl() { return fGL; }
 
 private:
-    SkGLContext* fGL;
+    GLContext* fGL;
     SkAutoTDelete<SkSurface> fSurface;
 };
 
 static bool write_canvas_png(GPUTarget* target, const SkString& filename) {
 
     if (filename.isEmpty()) {
         return false;
     }
     if (target->getCanvas() &&
         kUnknown_SkColorType == target->getCanvas()->imageInfo().colorType()) {
@@ skipping 40 matching lines @@
     if (loops > FLAGS_maxLoops) {
         SkDebugf("WARNING: clamping loops from %d to FLAGS_maxLoops, %d.\n", loops, FLAGS_maxLoops);
         return FLAGS_maxLoops;
     }
     return loops;
 }
 
 static double now_ms() { return SkTime::GetNSecs() * 1e-6; }
 
 struct TimingThread {
-    TimingThread(SkGLContext* mainContext)
+    TimingThread(GLContext* mainContext)
         : fFenceSync(mainContext->fenceSync())
         ,  fMainContext(mainContext)
         ,  fDone(false) {}
 
     static void Loop(void* data) {
         TimingThread* timingThread = reinterpret_cast<TimingThread*>(data);
         timingThread->timingLoop();
     }
 
     // To ensure waiting for the sync actually does something, we check to make sure the we exceed
     // some small value
     const double kMinElapsed = 1e-6;
     bool sanity(double start) const {
         double elapsed = now_ms() - start;
         return elapsed > kMinElapsed;
     }
 
     void waitFence(SkPlatformGpuFence sync) {
         SkDEBUGCODE(double start = now_ms());
         fFenceSync->waitFence(sync, false);
         SkASSERT(sanity(start));
     }
 
     void timingLoop() {
         // Create a context which shares display lists with the main thread
-        SkAutoTDelete<SkGLContext> glContext(SkCreatePlatformGLContext(kNone_GrGLStandard,
-                                                                       fMainContext));
+        SkAutoTDelete<GLContext> glContext(CreatePlatformGLContext(kNone_GrGLStandard,
+                                                                   fMainContext));
         glContext->makeCurrent();
 
         // Basic timing methodology is:
         // 1) Wait on semaphore until main thread indicates its time to start timing the frame
         // 2) Wait on frame start sync, record time.  This is start of the frame.
         // 3) Wait on semaphore until main thread indicates its time to finish timing the frame
         // 4) Wait on frame end sync, record time.  FrameEndTime - FrameStartTime = frame time
         // 5) Wait on semaphore until main thread indicates we should time the next frame or quit
         while (true) {
             fSemaphore.wait();
@@ skipping 75 matching lines @@
 
 private:
     SkGpuFenceSync* fFenceSync;
     SkSemaphore fSemaphore;
     SkMutex fFrameStartSyncsMutex;
     SyncQueue fFrameStartSyncs;
     SkMutex fFrameEndSyncsMutex;
     SyncQueue fFrameEndSyncs;
     SkTArray<double> fTimings;
     SkMutex fDoneMutex;
-    SkGLContext* fMainContext;
+    GLContext* fMainContext;
     bool fDone;
 };
 
 static double time(int loops, Benchmark* bench, GPUTarget* target, TimingThread* timingThread) {
     SkCanvas* canvas = target->getCanvas();
     canvas->clear(SK_ColorWHITE);
     bench->preDraw(canvas);
 
     if (timingThread) {
         timingThread->pushStartSync();
@@ skipping 229 matching lines @@
     }
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return kilobench_main();
 }
 #endif