rename sk_gpu_test::GLContext to sk_gpu_test::GLTestContext

tools/gpu/gl/command_buffer/GLTestContext_command_buffer.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkOnce.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLAssembleInterface.h"
-#include "gl/command_buffer/GLContext_command_buffer.h"
+#include "gl/command_buffer/GLTestContext_command_buffer.h"
 #include "../ports/SkOSEnvironment.h"
 #include "../ports/SkOSLibrary.h"
 
 #if defined SK_BUILD_FOR_MAC
 
 // EGL doesn't exist on the mac, so expose what we need to get the command buffer's EGL running.
 typedef void *EGLDisplay;
 typedef unsigned int EGLBoolean;
 typedef void *EGLConfig;
 typedef void *EGLSurface;
@@ skipping 113 matching lines @@
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
     return GrGLAssembleGLESInterface(gLibrary, command_buffer_get_gl_proc);
 }
 
 }  // anonymous namespace
 
 namespace sk_gpu_test {
 
-CommandBufferGLContext::CommandBufferGLContext()
+CommandBufferGLTestContext::CommandBufferGLTestContext()
     : fContext(EGL_NO_CONTEXT), fDisplay(EGL_NO_DISPLAY), fSurface(EGL_NO_SURFACE) {
 
     static const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_RED_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_ALPHA_SIZE, 8,
         EGL_NONE
     };
 
     static const EGLint surfaceAttribs[] = {
         EGL_WIDTH, 1,
         EGL_HEIGHT, 1,
         EGL_NONE
     };
 
     initializeGLContext(nullptr, configAttribs, surfaceAttribs);
 }
 
-CommandBufferGLContext::CommandBufferGLContext(void *nativeWindow, int msaaSampleCount) {
+CommandBufferGLTestContext::CommandBufferGLTestContext(void *nativeWindow, int msaaSampleCount) {
     static const EGLint surfaceAttribs[] = {EGL_NONE};
 
     EGLint configAttribs[] = {
         EGL_RED_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_ALPHA_SIZE, 8,
         EGL_DEPTH_SIZE, 8,
         EGL_STENCIL_SIZE, 8,
         EGL_SAMPLE_BUFFERS, 1,
         EGL_SAMPLES, msaaSampleCount,
         EGL_NONE
     };
     if (msaaSampleCount == 0) {
         configAttribs[12] = EGL_NONE;
     }
 
     initializeGLContext(nativeWindow, configAttribs, surfaceAttribs);
 }
 
-void CommandBufferGLContext::initializeGLContext(void *nativeWindow, const int *configAttribs,
+void CommandBufferGLTestContext::initializeGLContext(void *nativeWindow, const int *configAttribs,
                                                  const int *surfaceAttribs) {
     load_command_buffer_once();
     if (!gfFunctionsLoadedSuccessfully) {
         SkDebugf("Command Buffer: Could not load EGL functions.\n");
         return;
     }
 
     // Make sure CHROMIUM_path_rendering is enabled for NVPR support.
     sk_setenv("CHROME_COMMAND_BUFFER_GLES2_ARGS", "--enable-gl-path-rendering");
     fDisplay = gfGetDisplay(EGL_DEFAULT_DISPLAY);
@@ skipping 59 matching lines @@
     }
     if (!gl->validate()) {
         SkDebugf("Command Buffer: Could not validate CommandBuffer GL interface.\n");
         this->destroyGLContext();
         return;
     }
 
     this->init(gl.release());
 }
 
-CommandBufferGLContext::~CommandBufferGLContext() {
+CommandBufferGLTestContext::~CommandBufferGLTestContext() {
     this->teardown();
     this->destroyGLContext();
 }
 
-void CommandBufferGLContext::destroyGLContext() {
+void CommandBufferGLTestContext::destroyGLContext() {
     if (!gfFunctionsLoadedSuccessfully) {
         return;
     }
     if (fDisplay) {
         gfMakeCurrent(fDisplay, 0, 0, 0);
 
         if (fContext) {
             gfDestroyContext(fDisplay, fContext);
             fContext = EGL_NO_CONTEXT;
         }
 
         if (fSurface) {
             gfDestroySurface(fDisplay, fSurface);
             fSurface = EGL_NO_SURFACE;
         }
 
         gfTerminate(fDisplay);
         fDisplay = EGL_NO_DISPLAY;
     }
 }
 
-void CommandBufferGLContext::onPlatformMakeCurrent() const {
+void CommandBufferGLTestContext::onPlatformMakeCurrent() const {
     if (!gfFunctionsLoadedSuccessfully) {
         return;
     }
     if (!gfMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
         SkDebugf("Command Buffer: Could not make EGL context current.\n");
     }
 }
 
-void CommandBufferGLContext::onPlatformSwapBuffers() const {
+void CommandBufferGLTestContext::onPlatformSwapBuffers() const {
     if (!gfFunctionsLoadedSuccessfully) {
         return;
     }
     if (!gfSwapBuffers(fDisplay, fSurface)) {
         SkDebugf("Command Buffer: Could not complete gfSwapBuffers.\n");
     }
 }
 
-GrGLFuncPtr CommandBufferGLContext::onPlatformGetProcAddress(const char *name) const {
+GrGLFuncPtr CommandBufferGLTestContext::onPlatformGetProcAddress(const char *name) const {
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
     return gfGetProcAddress(name);
 }
 
-void CommandBufferGLContext::presentCommandBuffer() {
+void CommandBufferGLTestContext::presentCommandBuffer() {
     if (this->gl()) {
         this->gl()->fFunctions.fFlush();
     }
 
     this->onPlatformSwapBuffers();
 }
 
-bool CommandBufferGLContext::makeCurrent() {
+bool CommandBufferGLTestContext::makeCurrent() {
     return gfMakeCurrent(fDisplay, fSurface, fSurface, fContext) != EGL_FALSE;
 }
 
-int CommandBufferGLContext::getStencilBits() {
+int CommandBufferGLTestContext::getStencilBits() {
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_STENCIL_SIZE, &result);
     return result;
 }
 
-int CommandBufferGLContext::getSampleCount() {
+int CommandBufferGLTestContext::getSampleCount() {
     EGLint result = 0;
     gfGetConfigAttrib(fDisplay, static_cast<EGLConfig>(fConfig), EGL_SAMPLES, &result);
     return result;
 }
 
 }  // namespace sk_gpu_test