rename sk_gpu_test::GLContext to sk_gpu_test::GLTestContext

tools/gpu/gl/glx/CreatePlatformGLTestContext_glx.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"
 
 #include <X11/Xlib.h>
 #include <GL/glx.h>
 #include <GL/glu.h>
 
 namespace {
 
 /* Note: Skia requires glx 1.3 or newer */
 
 /* This struct is taken from a mesa demo.  Please update as required */
@@ skipping 18 matching lines @@
    {0, 0} /* end of list */
 };
 #define NUM_GL_VERSIONS SK_ARRAY_COUNT(gl_versions)
 
 static bool ctxErrorOccurred = false;
 static int ctxErrorHandler(Display *dpy, XErrorEvent *ev) {
     ctxErrorOccurred = true;
     return 0;
 }
 
-class GLXGLContext : public sk_gpu_test::GLContext {
+class GLXGLTestContext : public sk_gpu_test::GLTestContext {
 public:
-    GLXGLContext(GrGLStandard forcedGpuAPI, GLXGLContext* shareList);
-    ~GLXGLContext() override;
+    GLXGLTestContext(GrGLStandard forcedGpuAPI, GLXGLTestContext* shareList);
+    ~GLXGLTestContext() override;
 
 private:
     void destroyGLContext();
 
     void onPlatformMakeCurrent() const override;
     void onPlatformSwapBuffers() const override;
     GrGLFuncPtr onPlatformGetProcAddress(const char*) const override;
 
     GLXContext fContext;
     Display* fDisplay;
     Pixmap fPixmap;
     GLXPixmap fGlxPixmap;
 };
 
-GLXGLContext::GLXGLContext(GrGLStandard forcedGpuAPI, GLXGLContext* shareContext)
+GLXGLTestContext::GLXGLTestContext(GrGLStandard forcedGpuAPI, GLXGLTestContext* shareContext)
     : fContext(nullptr)
     , fDisplay(nullptr)
     , fPixmap(0)
     , fGlxPixmap(0) {
     fDisplay = XOpenDisplay(0);
 
     GLXContext glxShareContext = shareContext ? shareContext->fContext : nullptr;
 
     if (!fDisplay) {
         SkDebugf("Failed to open X display.\n");
@@ skipping 205 matching lines @@
     if (!gl->validate()) {
         SkDebugf("Failed to validate gl interface");
         this->destroyGLContext();
         return;
     }
 
     this->init(gl.release());
 }
 
 
-GLXGLContext::~GLXGLContext() {
+GLXGLTestContext::~GLXGLTestContext() {
     this->teardown();
     this->destroyGLContext();
 }
 
-void GLXGLContext::destroyGLContext() {
+void GLXGLTestContext::destroyGLContext() {
     if (fDisplay) {
         glXMakeCurrent(fDisplay, 0, 0);
 
         if (fContext) {
             glXDestroyContext(fDisplay, fContext);
             fContext = nullptr;
         }
 
         if (fGlxPixmap) {
             glXDestroyGLXPixmap(fDisplay, fGlxPixmap);
             fGlxPixmap = 0;
         }
 
         if (fPixmap) {
             XFreePixmap(fDisplay, fPixmap);
             fPixmap = 0;
         }
 
         XCloseDisplay(fDisplay);
         fDisplay = nullptr;
     }
 }
 
-void GLXGLContext::onPlatformMakeCurrent() const {
+void GLXGLTestContext::onPlatformMakeCurrent() const {
     if (!glXMakeCurrent(fDisplay, fGlxPixmap, fContext)) {
         SkDebugf("Could not set the context.\n");
     }
 }
 
-void GLXGLContext::onPlatformSwapBuffers() const {
+void GLXGLTestContext::onPlatformSwapBuffers() const {
     glXSwapBuffers(fDisplay, fGlxPixmap);
 }
 
-GrGLFuncPtr GLXGLContext::onPlatformGetProcAddress(const char* procName) const {
+GrGLFuncPtr GLXGLTestContext::onPlatformGetProcAddress(const char* procName) const {
     return glXGetProcAddress(reinterpret_cast<const GLubyte*>(procName));
 }
 
 }  // anonymous namespace
 
 namespace sk_gpu_test {
-GLContext *CreatePlatformGLContext(GrGLStandard forcedGpuAPI, GLContext *shareContext) {
-    GLXGLContext *glxShareContext = reinterpret_cast<GLXGLContext *>(shareContext);
-    GLXGLContext *ctx = new GLXGLContext(forcedGpuAPI, glxShareContext);
+GLTestContext *CreatePlatformGLTestContext(GrGLStandard forcedGpuAPI,
+                                           GLTestContext *shareContext) {
+    GLXGLTestContext *glxShareContext = reinterpret_cast<GLXGLTestContext *>(shareContext);
+    GLXGLTestContext *ctx = new GLXGLTestContext(forcedGpuAPI, glxShareContext);
     if (!ctx->isValid()) {
         delete ctx;
         return nullptr;
     }
     return ctx;
 }
 }  // namespace sk_gpu_test