Revert of rename sk_gpu_test::GLContext to sk_gpu_test::GLTestContext

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"
@@ skipping 200 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;
     }
 
-    GLTestContext* gl() { return fGL; }
+    GLContext* gl() { return fGL; }
 
 private:
-    GLTestContext* 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(GLTestContext* 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<GLTestContext> glContext(CreatePlatformGLTestContext(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;
-    GLTestContext* 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