add wait on fence without flush

src/gpu/gl/SkGLContext.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 "gl/SkGLContext.h"
 #include "GrGLUtil.h"
 #include "SkGpuFenceSync.h"
 
 class SkGLContext::GLFenceSync : public SkGpuFenceSync {
 public:
     static GLFenceSync* CreateIfSupported(const SkGLContext*);
 
     SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const override;
-    bool flushAndWaitFence(SkPlatformGpuFence fence) const override;
+    bool waitFence(SkPlatformGpuFence fence, bool flush) const override;
     void deleteFence(SkPlatformGpuFence fence) const override;
 
 private:
     GLFenceSync() {}
 
     static const GrGLenum GL_SYNC_GPU_COMMANDS_COMPLETE  = 0x9117;
     static const GrGLenum GL_WAIT_FAILED                 = 0x911d;
     static const GrGLbitfield GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001;
 
     typedef struct __GLsync *GLsync;
@@ skipping 50 matching lines @@
 }
 
 void SkGLContext::swapBuffers() {
     if (!fFenceSync) {
         // Fallback on the platform SwapBuffers method for synchronization. This may have no effect.
         this->onPlatformSwapBuffers();
         return;
     }
 
     if (fFrameFences[fCurrentFenceIdx]) {
-        if (!fFenceSync->flushAndWaitFence(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);
 }
 
 void SkGLContext::testAbandon() {
@@ skipping 37 matching lines @@
         return nullptr;
     }
 
     return ret.detach();
 }
 
 SkPlatformGpuFence SkGLContext::GLFenceSync::insertFence() const {
     return fGLFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 }
 
-bool SkGLContext::GLFenceSync::flushAndWaitFence(SkPlatformGpuFence fence) const {
+bool SkGLContext::GLFenceSync::waitFence(SkPlatformGpuFence fence, bool flush) const {
     GLsync glsync = static_cast<GLsync>(fence);
-    return GL_WAIT_FAILED != fGLClientWaitSync(glsync, GL_SYNC_FLUSH_COMMANDS_BIT, -1);
+    return GL_WAIT_FAILED != fGLClientWaitSync(glsync, flush ? GL_SYNC_FLUSH_COMMANDS_BIT : 0, -1);
 }
 
 void SkGLContext::GLFenceSync::deleteFence(SkPlatformGpuFence fence) const {
     GLsync glsync = static_cast<GLsync>(fence);
     fGLDeleteSync(glsync);
 }
 
 GrGLint SkGLContext::createTextureRectangle(int width, int height, GrGLenum internalFormat,
                                             GrGLenum externalFormat, GrGLenum externalType,
                                             GrGLvoid* data) {
@@ skipping 14 matching lines @@
     GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_MIN_FILTER,
                                   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;
 }