Add base class for GLTestContext and add new subclass VkTestContext.

tools/gpu/gl/GLTestContext.cpp

-
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "GLTestContext.h"
 #include "gl/GrGLUtil.h"
-#include "SkGpuFenceSync.h"
 
 namespace sk_gpu_test {
 class GLTestContext::GLFenceSync : public SkGpuFenceSync {
 public:
     static GLFenceSync* CreateIfSupported(const GLTestContext*);
 
     SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const override;
     bool waitFence(SkPlatformGpuFence fence, bool flush) const override;
     void deleteFence(SkPlatformGpuFence fence) const override;
 
@@ skipping 10 matching lines @@
     typedef GrGLenum (GR_GL_FUNCTION_TYPE* GLClientWaitSyncProc) (GLsync, GrGLbitfield, GrGLuint64);
     typedef GrGLvoid (GR_GL_FUNCTION_TYPE* GLDeleteSyncProc) (GLsync);
 
     GLFenceSyncProc        fGLFenceSync;
     GLClientWaitSyncProc   fGLClientWaitSync;
     GLDeleteSyncProc       fGLDeleteSync;
 
     typedef SkGpuFenceSync INHERITED;
 };
 
-GLTestContext::GLTestContext()
-    : fCurrentFenceIdx(0) {
-    memset(fFrameFences, 0, sizeof(fFrameFences));
-}
+GLTestContext::GLTestContext() : TestContext() {}
 
 GLTestContext::~GLTestContext() {
-    // Subclass should call teardown.
-#ifdef SK_DEBUG
-    for (size_t i = 0; i < SK_ARRAY_COUNT(fFrameFences); i++) {
-        SkASSERT(0 == fFrameFences[i]);
-    }
-#endif
     SkASSERT(nullptr == fGL.get());
-    SkASSERT(nullptr == fFenceSync.get());
 }
 
 void GLTestContext::init(const GrGLInterface* gl, SkGpuFenceSync* fenceSync) {
     SkASSERT(!fGL.get());
     fGL.reset(gl);
-    fFenceSync.reset(fenceSync ? fenceSync : GLFenceSync::CreateIfSupported(this));
+    fFenceSync = fenceSync ? fenceSync : GLFenceSync::CreateIfSupported(this);
 }
 
 void GLTestContext::teardown() {
-    if (fFenceSync) {
-        for (size_t i = 0; i < SK_ARRAY_COUNT(fFrameFences); i++) {
-            if (fFrameFences[i]) {
-                fFenceSync->deleteFence(fFrameFences[i]);
-                fFrameFences[i] = 0;
-            }
-        }
-        fFenceSync.reset(nullptr);
-    }
-
     fGL.reset(nullptr);
-}
-
-void GLTestContext::makeCurrent() const {
-    this->onPlatformMakeCurrent();
-}
-
-void GLTestContext::swapBuffers() {
-    this->onPlatformSwapBuffers();
-}
-
-void GLTestContext::waitOnSyncOrSwap() {
-    if (!fFenceSync) {
-        // Fallback on the platform SwapBuffers method for synchronization. This may have no effect.
-        this->swapBuffers();
-        return;
-    }
-
-    if (fFrameFences[fCurrentFenceIdx]) {
-        if (!fFenceSync->waitFence(fFrameFences[fCurrentFenceIdx], true)) {
-            SkDebugf("WARNING: Wait failed for fence sync. Timings might not be accurate.\n");
-        }
-        fFenceSync->deleteFence(fFrameFences[fCurrentFenceIdx]);
-    }
-
-    fFrameFences[fCurrentFenceIdx] = fFenceSync->insertFence();
-    fCurrentFenceIdx = (fCurrentFenceIdx + 1) % SK_ARRAY_COUNT(fFrameFences);
+    INHERITED::teardown();
 }
 
 void GLTestContext::testAbandon() {
+    INHERITED::testAbandon();
     if (fGL) {
         fGL->abandon();
     }
-    if (fFenceSync) {
-        memset(fFrameFences, 0, sizeof(fFrameFences));
-    }
 }
 
 GLTestContext::GLFenceSync* GLTestContext::GLFenceSync::CreateIfSupported(const GLTestContext* ctx) {
     SkAutoTDelete<GLFenceSync> ret(new GLFenceSync);
 
     if (kGL_GrGLStandard == ctx->gl()->fStandard) {
         const GrGLubyte* versionStr;
         GR_GL_CALL_RET(ctx->gl(), versionStr, GetString(GR_GL_VERSION));
         GrGLVersion version = GrGLGetVersionFromString(reinterpret_cast<const char*>(versionStr));
         if (version < GR_GL_VER(3,2) && !ctx->gl()->hasExtension("GL_ARB_sync")) {
@@ skipping 59 matching lines @@
                                   GR_GL_NEAREST));
     GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_S,
                                   GR_GL_CLAMP_TO_EDGE));    
     GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_T,
                                   GR_GL_CLAMP_TO_EDGE));
     GR_GL_CALL(fGL, TexImage2D(GR_GL_TEXTURE_RECTANGLE, 0, internalFormat, width, height, 0,
                                externalFormat, externalType, data));
     return id;
 }
 }  // namespace sk_gpu_test