rename sk_gpu_test::GLContext to sk_gpu_test::GLTestContext

tools/gpu/gl/egl/CreatePlatformGLTestContext_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/GLContext.h"
+#include "gl/GLTestContext.h"
 
+#define GL_GLEXT_PROTOTYPES
 #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 {
+class EGLFenceSync : public SkGpuFenceSync {
 public:
-    static SkEGLFenceSync* CreateIfSupported(EGLDisplay);
+    static EGLFenceSync* 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) {}
+    EGLFenceSync(EGLDisplay display) : fDisplay(display) {}
 
     EGLDisplay                    fDisplay;
 
     typedef SkGpuFenceSync INHERITED;
 };
 
-class EGLGLContext : public sk_gpu_test::GLContext {
+class EGLGLTestContext : public sk_gpu_test::GLTestContext {
 public:
-    EGLGLContext(GrGLStandard forcedGpuAPI);
-    ~EGLGLContext() override;
+    EGLGLTestContext(GrGLStandard forcedGpuAPI);
+    ~EGLGLTestContext() override;
 
     GrEGLImage texture2DToEGLImage(GrGLuint texID) const override;
     void destroyEGLImage(GrEGLImage) const override;
     GrGLuint eglImageToExternalTexture(GrEGLImage) const override;
-    sk_gpu_test::GLContext* createNew() const override;
+    sk_gpu_test::GLTestContext* createNew() const override;
 
 private:
     void destroyGLContext();
 
     void onPlatformMakeCurrent() const override;
     void onPlatformSwapBuffers() const override;
     GrGLFuncPtr onPlatformGetProcAddress(const char*) const override;
 
     EGLContext fContext;
     EGLDisplay fDisplay;
     EGLSurface fSurface;
 };
 
-EGLGLContext::EGLGLContext(GrGLStandard forcedGpuAPI)
+EGLGLTestContext::EGLGLTestContext(GrGLStandard forcedGpuAPI)
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
     , fSurface(EGL_NO_SURFACE) {
     static const EGLint kEGLContextAttribsForOpenGL[] = {
         EGL_NONE
     };
 
     static const EGLint kEGLContextAttribsForOpenGLES[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE
@@ skipping 101 matching lines @@
             this->destroyGLContext();
             continue;
         }
 
         if (!gl->validate()) {
             SkDebugf("Failed to validate gl interface.\n");
             this->destroyGLContext();
             continue;
         }
 
-        this->init(gl.release(), SkEGLFenceSync::CreateIfSupported(fDisplay));
+        this->init(gl.release(), EGLFenceSync::CreateIfSupported(fDisplay));
         break;
     }
 }
 
-EGLGLContext::~EGLGLContext() {
+EGLGLTestContext::~EGLGLTestContext() {
     this->teardown();
     this->destroyGLContext();
 }
 
-void EGLGLContext::destroyGLContext() {
+void EGLGLTestContext::destroyGLContext() {
     if (fDisplay) {
         eglMakeCurrent(fDisplay, 0, 0, 0);
 
         if (fContext) {
             eglDestroyContext(fDisplay, fContext);
             fContext = EGL_NO_CONTEXT;
         }
 
         if (fSurface) {
             eglDestroySurface(fDisplay, fSurface);
             fSurface = EGL_NO_SURFACE;
         }
 
         //TODO should we close the display?
         fDisplay = EGL_NO_DISPLAY;
     }
 }
 
-GrEGLImage EGLGLContext::texture2DToEGLImage(GrGLuint texID) const {
+GrEGLImage EGLGLTestContext::texture2DToEGLImage(GrGLuint texID) const {
     if (!this->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) {
         return GR_EGL_NO_IMAGE;
     }
     GrEGLImage img;
     GrEGLint attribs[] = { GR_EGL_GL_TEXTURE_LEVEL, 0, GR_EGL_NONE };
     GrEGLClientBuffer clientBuffer = reinterpret_cast<GrEGLClientBuffer>(texID);
     GR_GL_CALL_RET(this->gl(), img,
                    EGLCreateImage(fDisplay, fContext, GR_EGL_GL_TEXTURE_2D, clientBuffer, attribs));
     return img;
 }
 
-void EGLGLContext::destroyEGLImage(GrEGLImage image) const {
+void EGLGLTestContext::destroyEGLImage(GrEGLImage image) const {
     GR_GL_CALL(this->gl(), EGLDestroyImage(fDisplay, image));
 }
 
-GrGLuint EGLGLContext::eglImageToExternalTexture(GrEGLImage image) const {
+GrGLuint EGLGLTestContext::eglImageToExternalTexture(GrEGLImage image) const {
     GrGLClearErr(this->gl());
     if (!this->gl()->hasExtension("GL_OES_EGL_image_external")) {
         return 0;
     }
     typedef GrGLvoid (*EGLImageTargetTexture2DProc)(GrGLenum, GrGLeglImage);
 
     EGLImageTargetTexture2DProc glEGLImageTargetTexture2D =
         (EGLImageTargetTexture2DProc) eglGetProcAddress("glEGLImageTargetTexture2DOES");
     if (!glEGLImageTargetTexture2D) {
         return 0;
     }
     GrGLuint texID;
     glGenTextures(1, &texID);
     if (!texID) {
         return 0;
     }
     glBindTexture(GR_GL_TEXTURE_EXTERNAL, texID);
     if (glGetError() != GR_GL_NO_ERROR) {
         glDeleteTextures(1, &texID);
         return 0;
     }
     glEGLImageTargetTexture2D(GR_GL_TEXTURE_EXTERNAL, image);
     if (glGetError() != GR_GL_NO_ERROR) {
         glDeleteTextures(1, &texID);
         return 0;
     }
     return texID;
 }
 
-sk_gpu_test::GLContext* EGLGLContext::createNew() const {
-    sk_gpu_test::GLContext* ctx = new EGLGLContext(this->gl()->fStandard);
+sk_gpu_test::GLTestContext* EGLGLTestContext::createNew() const {
+    sk_gpu_test::GLTestContext* ctx = new EGLGLTestContext(this->gl()->fStandard);
     if (ctx) {
         ctx->makeCurrent();
     }
     return ctx;
 }
 
-void EGLGLContext::onPlatformMakeCurrent() const {
+void EGLGLTestContext::onPlatformMakeCurrent() const {
     if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
         SkDebugf("Could not set the context.\n");
     }
 }
 
-void EGLGLContext::onPlatformSwapBuffers() const {
+void EGLGLTestContext::onPlatformSwapBuffers() const {
     if (!eglSwapBuffers(fDisplay, fSurface)) {
         SkDebugf("Could not complete eglSwapBuffers.\n");
     }
 }
 
-GrGLFuncPtr EGLGLContext::onPlatformGetProcAddress(const char* procName) const {
+GrGLFuncPtr EGLGLTestContext::onPlatformGetProcAddress(const char* procName) const {
     return eglGetProcAddress(procName);
 }
 
 static bool supports_egl_extension(EGLDisplay display, const char* extension) {
     size_t extensionLength = strlen(extension);
     const char* extensionsStr = eglQueryString(display, EGL_EXTENSIONS);
     while (const char* match = strstr(extensionsStr, extension)) {
         // Ensure the string we found is its own extension, not a substring of a larger extension
         // (e.g. GL_ARB_occlusion_query / GL_ARB_occlusion_query2).
         if ((match == extensionsStr || match[-1] == ' ') &&
             (match[extensionLength] == ' ' || match[extensionLength] == '\0')) {
             return true;
         }
         extensionsStr = match + extensionLength;
     }
     return false;
 }
 
-SkEGLFenceSync* SkEGLFenceSync::CreateIfSupported(EGLDisplay display) {
+EGLFenceSync* EGLFenceSync::CreateIfSupported(EGLDisplay display) {
     if (!display || !supports_egl_extension(display, "EGL_KHR_fence_sync")) {
         return nullptr;
     }
-    return new SkEGLFenceSync(display);
+    return new EGLFenceSync(display);
 }
 
-SkPlatformGpuFence SkEGLFenceSync::insertFence() const {
+SkPlatformGpuFence EGLFenceSync::insertFence() const {
     return eglCreateSyncKHR(fDisplay, EGL_SYNC_FENCE_KHR, nullptr);
 }
 
-bool SkEGLFenceSync::waitFence(SkPlatformGpuFence platformFence, bool flush) const {
+bool EGLFenceSync::waitFence(SkPlatformGpuFence platformFence, bool flush) const {
     EGLSyncKHR eglsync = static_cast<EGLSyncKHR>(platformFence);
     return EGL_CONDITION_SATISFIED_KHR ==
             eglClientWaitSyncKHR(fDisplay,
                                  eglsync,
                                  flush ? EGL_SYNC_FLUSH_COMMANDS_BIT_KHR : 0,
                                  EGL_FOREVER_KHR);
 }
 
-void SkEGLFenceSync::deleteFence(SkPlatformGpuFence platformFence) const {
+void EGLFenceSync::deleteFence(SkPlatformGpuFence platformFence) const {
     EGLSyncKHR eglsync = static_cast<EGLSyncKHR>(platformFence);
     eglDestroySyncKHR(fDisplay, eglsync);
 }
 
 }  // anonymous namespace
 
 namespace sk_gpu_test {
-GLContext *CreatePlatformGLContext(GrGLStandard forcedGpuAPI, GLContext *shareContext) {
+GLTestContext *CreatePlatformGLTestContext(GrGLStandard forcedGpuAPI,
+                                           GLTestContext *shareContext) {
     SkASSERT(!shareContext);
     if (shareContext) {
         return nullptr;
     }
-    EGLGLContext *ctx = new EGLGLContext(forcedGpuAPI);
+    EGLGLTestContext *ctx = new EGLGLTestContext(forcedGpuAPI);
     if (!ctx->isValid()) {
         delete ctx;
         return nullptr;
     }
     return ctx;
 }
 }  // namespace sk_gpu_test