Improving support for WebGL2 Query objects

Source/core/html/canvas/WebGL2RenderingContextBase.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/html/canvas/WebGL2RenderingContextBase.h"
 
 #include "bindings/core/v8/WebGLAny.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 37 matching lines @@
 WebGL2RenderingContextBase::~WebGL2RenderingContextBase()
 {
     m_readFramebufferBinding = nullptr;
 
     m_boundCopyReadBuffer = nullptr;
     m_boundCopyWriteBuffer = nullptr;
     m_boundPixelPackBuffer = nullptr;
     m_boundPixelUnpackBuffer = nullptr;
     m_boundTransformFeedbackBuffer = nullptr;
     m_boundUniformBuffer = nullptr;
+
+    m_currentBooleanOcclusionQuery = nullptr;
+    m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
 }
 
 void WebGL2RenderingContextBase::initializeNewContext()
 {
     ASSERT(!isContextLost());
     ASSERT(drawingBuffer());
 
     m_readFramebufferBinding = nullptr;
 
     m_boundCopyReadBuffer = nullptr;
     m_boundCopyWriteBuffer = nullptr;
     m_boundPixelPackBuffer = nullptr;
     m_boundPixelUnpackBuffer = nullptr;
     m_boundTransformFeedbackBuffer = nullptr;
     m_boundUniformBuffer = nullptr;
 
+    m_currentBooleanOcclusionQuery = nullptr;
+    m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
+
     m_max3DTextureSize = 0;
     webContext()->getIntegerv(GL_MAX_3D_TEXTURE_SIZE, &m_max3DTextureSize);
     m_max3DTextureLevel = WebGLTexture::computeLevelCount(m_max3DTextureSize, m_max3DTextureSize, m_max3DTextureSize);
 
     WebGLRenderingContextBase::initializeNewContext();
 }
 
 void WebGL2RenderingContextBase::copyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
     if (isContextLost())
@@ skipping 952 matching lines @@
 {
     if (isContextLost())
         return nullptr;
     RefPtrWillBeRawPtr<WebGLQuery> o = WebGLQuery::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteQuery(WebGLQuery* query)
 {
+    if (m_currentBooleanOcclusionQuery == query) {
+        webContext()->endQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
+        m_currentBooleanOcclusionQuery = nullptr;
+    }
+
+    if (m_currentTransformFeedbackPrimitivesWrittenQuery == query) {
+        webContext()->endQueryEXT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+        m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
+    }
+
     deleteObject(query);
 }
 
 GLboolean WebGL2RenderingContextBase::isQuery(WebGLQuery* query)
 {
     if (isContextLost() || !query)
         return 0;
 
     return webContext()->isQueryEXT(query->object());
 }
 
 void WebGL2RenderingContextBase::beginQuery(GLenum target, WebGLQuery* query)
 {
-    if (isContextLost() || !validateWebGLObject("beginQuery", query))
+    bool deleted;
+    if (!checkObjectToBeBound("beginQuery", query, deleted))
         return;
+    if (deleted) {
+        synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "attempted to begin a deleted query object");
+        return;
+    }
+
+    if (!query->isCompatibleTarget(target)) {
+        synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "query type does not match target");
+        return;
+    }
+
+    switch (target) {
+    case GL_ANY_SAMPLES_PASSED:
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
+        {
+            if (m_currentBooleanOcclusionQuery) {
+                synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "a query is already active for target");
+                return;
+            }
+            m_currentBooleanOcclusionQuery = query;
+        }
+        break;
+    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
+        {
+            if (m_currentTransformFeedbackPrimitivesWrittenQuery) {
+                synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "a query is already active for target");
+                return;
+            }
+            m_currentTransformFeedbackPrimitivesWrittenQuery = query;
+        }
+        break;
+    default:
+        synthesizeGLError(GL_INVALID_ENUM, "beginQuery", "invalid target");
+        return;
+    }
+
+    query->setTarget(target);
 
     webContext()->beginQueryEXT(target, query->object());
 }
 
 void WebGL2RenderingContextBase::endQuery(GLenum target)
 {
     if (isContextLost())
         return;
 
+    switch (target) {
+    case GL_ANY_SAMPLES_PASSED:
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
+        {
+            if (m_currentBooleanOcclusionQuery && m_currentBooleanOcclusionQuery->getTarget() == target) {
+                m_currentBooleanOcclusionQuery = nullptr;
+            } else {
+                synthesizeGLError(GL_INVALID_OPERATION, "endQuery", "target query is not active");
+                return;
+            }
+        }
+        break;
+    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
+        {
+            if (m_currentTransformFeedbackPrimitivesWrittenQuery) {
+                m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
+            } else {
+                synthesizeGLError(GL_INVALID_OPERATION, "endQuery", "target query is not active");
+                return;
+            }
+        }
+        break;
+    default:
+        synthesizeGLError(GL_INVALID_ENUM, "endQuery", "invalid target");
+        return;
+    }
+
     webContext()->endQueryEXT(target);
 }
 
 PassRefPtrWillBeRawPtr<WebGLQuery> WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return nullptr;
 
-    notImplemented();
+    if (pname != GL_CURRENT_QUERY) {
+        synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid parameter name");
+        return nullptr;
+    }
+
+    switch (target) {
+    case GL_ANY_SAMPLES_PASSED:
+    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
+        if (m_currentBooleanOcclusionQuery && m_currentBooleanOcclusionQuery->getTarget() == target)
+            return PassRefPtrWillBeRawPtr<WebGLQuery>(m_currentBooleanOcclusionQuery.get());
+        break;
+    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
+        return PassRefPtrWillBeRawPtr<WebGLQuery>(m_currentTransformFeedbackPrimitivesWrittenQuery.get());
+    default:
+        synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid target");
+        return nullptr;
+    }
     return nullptr;
 }
 
 ScriptValue WebGL2RenderingContextBase::getQueryParameter(ScriptState* scriptState, WebGLQuery* query, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getQueryParameter", query))
         return ScriptValue::createNull(scriptState);
 
     switch (pname) {
     case GL_QUERY_RESULT:
@@ skipping 889 matching lines @@
 DEFINE_TRACE(WebGL2RenderingContextBase)
 {
     visitor->trace(m_readFramebufferBinding);
     visitor->trace(m_transformFeedbackBinding);
     visitor->trace(m_boundCopyReadBuffer);
     visitor->trace(m_boundCopyWriteBuffer);
     visitor->trace(m_boundPixelPackBuffer);
     visitor->trace(m_boundPixelUnpackBuffer);
     visitor->trace(m_boundTransformFeedbackBuffer);
     visitor->trace(m_boundUniformBuffer);
+    visitor->trace(m_currentBooleanOcclusionQuery);
+    visitor->trace(m_currentTransformFeedbackPrimitivesWrittenQuery);
     WebGLRenderingContextBase::trace(visitor);
 }
 
 WebGLTexture* WebGL2RenderingContextBase::validateTextureBinding(const char* functionName, GLenum target, bool useSixEnumsForCubeMap)
 {
     WebGLTexture* tex = nullptr;
     switch (target) {
     case GL_TEXTURE_2D_ARRAY:
         tex = m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get();
         if (!tex)
@@ skipping 127 matching lines @@
 GLenum WebGL2RenderingContextBase::boundFramebufferColorFormat()
 {
     if (m_readFramebufferBinding && m_readFramebufferBinding->object())
         return m_readFramebufferBinding->colorBufferFormat();
     if (m_requestedAttributes.alpha())
         return GL_RGBA;
     return GL_RGB;
 }
 
 } // namespace blink