Move SkGLContext and some GrGLInterface implementations to skgputest module

tools/gpu/gl/egl/CreatePlatformGLContext_egl.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-#include "gl/SkGLContext.h"
+#include "gl/GLContext.h"
 
 #include <GLES2/gl2.h>
 
 #define EGL_EGLEXT_PROTOTYPES
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLUtil.h"
 
 namespace {
 
 // TODO: Share this class with ANGLE if/when it gets support for EGL_KHR_fence_sync.
 class SkEGLFenceSync : public SkGpuFenceSync {
 public:
     static SkEGLFenceSync* CreateIfSupported(EGLDisplay);
 
     SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const override;
     bool waitFence(SkPlatformGpuFence fence, bool flush) const override;
     void deleteFence(SkPlatformGpuFence fence) const override;
 
 private:
     SkEGLFenceSync(EGLDisplay display) : fDisplay(display) {}
 
     EGLDisplay                    fDisplay;
 
     typedef SkGpuFenceSync INHERITED;
 };
 
-class EGLGLContext : public SkGLContext  {
+class EGLGLContext : public sk_gpu_test::GLContext {
 public:
     EGLGLContext(GrGLStandard forcedGpuAPI);
     ~EGLGLContext() override;
 
     GrEGLImage texture2DToEGLImage(GrGLuint texID) const override;
     void destroyEGLImage(GrEGLImage) const override;
     GrGLuint eglImageToExternalTexture(GrEGLImage) const override;
-    SkGLContext* createNew() const override;
+    sk_gpu_test::GLContext* createNew() const override;
 
 private:
     void destroyGLContext();
 
     void onPlatformMakeCurrent() const override;
     void onPlatformSwapBuffers() const override;
     GrGLFuncPtr onPlatformGetProcAddress(const char*) const override;
 
     EGLContext fContext;
     EGLDisplay fDisplay;
@@ skipping 190 matching lines @@
         return 0;
     }
     glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image);
     if (glGetError() != GR_GL_NO_ERROR) {
         glDeleteTextures(1, &texID);
         return 0;
     }
     return texID;
 }
 
-SkGLContext* EGLGLContext::createNew() const {
-    SkGLContext* ctx = SkCreatePlatformGLContext(this->gl()->fStandard);
+sk_gpu_test::GLContext* EGLGLContext::createNew() const {
+    sk_gpu_test::GLContext* ctx = new EGLGLContext(this->gl()->fStandard);
     if (ctx) {
         ctx->makeCurrent();
     }
     return ctx;
 }
 
 void EGLGLContext::onPlatformMakeCurrent() const {
     if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
         SkDebugf("Could not set the context.\n");
     }
@@ skipping 42 matching lines @@
                                  eglsync,
                                  flush ? EGL_SYNC_FLUSH_COMMANDS_BIT_KHR : 0,
                                  EGL_FOREVER_KHR);
 }
 
 void SkEGLFenceSync::deleteFence(SkPlatformGpuFence platformFence) const {
     EGLSyncKHR eglsync = static_cast<EGLSyncKHR>(platformFence);
     eglDestroySyncKHR(fDisplay, eglsync);
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
-SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI, SkGLContext* shareContext) {
+namespace sk_gpu_test {
+GLContext *CreatePlatformGLContext(GrGLStandard forcedGpuAPI, GLContext *shareContext) {
     SkASSERT(!shareContext);
     if (shareContext) {
         return nullptr;
     }
-    EGLGLContext* ctx = new EGLGLContext(forcedGpuAPI);
+    EGLGLContext *ctx = new EGLGLContext(forcedGpuAPI);
     if (!ctx->isValid()) {
         delete ctx;
         return nullptr;
     }
     return ctx;
 }
+}  // namespace sk_gpu_test