Move GPU fences into sk_gpu_test

tools/gpu/gl/GLTestContext.h

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef GLTestContext_DEFINED
 #define GLTestContext_DEFINED
 
+#include "SkTypes.h"
 #include "TestContext.h"
 #include "gl/GrGLInterface.h"
+#include <string>
 
 namespace sk_gpu_test {
 /**
  * An offscreen OpenGL context. Provides a GrGLInterface struct of function pointers for the context
  * This class is intended for Skia's internal testing needs and not for general use.
  */
 class GLTestContext : public TestContext {
 public:
     virtual ~GLTestContext();
 
@@ skipping 29 matching lines @@
 
     /** Wait until all GPU work is finished. */
     void finish() override;
 
     /**
      * Creates a new GL context of the same type and makes the returned context current
      * (if not null).
      */
     virtual GLTestContext *createNew() const { return nullptr; }
 
+    template<typename Ret, typename... Args>
+    void getGLProcAddress(Ret(**out)(Args...),
+                          const std::string& procname,
+                          const std::string& ext = "") const {

[csmartdalton, 2016/10/03 22:13:35]

Should we still be using SkString in internal tools?

[bsalomon, 2016/10/04 13:40:45]

I think so. Not that SkString is necessarily any better, but consistency. Maybe
we should consider a widespread conversion to std::string.

[csmartdalton, 2016/10/04 15:51:00]

Done.

+        using Proc = Ret(*)(Args...);
+        if (procname[0] != 'g' || procname[1] != 'l') {
+            SkFAIL("getGLProcAddress: proc name must have 'gl' prefix");
+            *out = nullptr;
+            return;
+        }
+        *out = reinterpret_cast<Proc>(this->onPlatformGetProcAddress((procname + ext).c_str()));
+    }
+
 protected:
     GLTestContext();
 
     /*
      * Methods that sublcasses must call from their constructors and destructors.
      */
-    void init(const GrGLInterface *, SkGpuFenceSync * = NULL);
+    void init(const GrGLInterface *, FenceSync* = nullptr);
 
     void teardown() override;
 
     virtual GrGLFuncPtr onPlatformGetProcAddress(const char *) const = 0;
 
 private:
-    class GLFenceSync;  // SkGpuFenceSync implementation that uses the OpenGL functionality.
-
     /** Subclass provides the gl interface object if construction was
      *  successful. */
     SkAutoTUnref<const GrGLInterface> fGL;
 
-    friend class GLFenceSync;  // For onPlatformGetProcAddress.
-
     typedef TestContext INHERITED;
 };
 
 /**
  * Creates platform-dependent GL context object.  The shareContext parameter is in an optional
  * context with which to share display lists. This should be a pointer to an GLTestContext created
  * with SkCreatePlatformGLTestContext.  NULL indicates that no sharing is to take place. Returns a
  * valid gl context object or NULL if such can not be created.
  */
 GLTestContext* CreatePlatformGLTestContext(GrGLStandard forcedGpuAPI,
                                            GLTestContext *shareContext = nullptr);
 
 }  // namespace sk_gpu_test
 #endif