Implement EXT_disjoint_timer_query_webgl2

third_party/WebKit/Source/modules/webgl/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 "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/dom/DOMException.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 219 matching lines @@
                                 2),
       m_readFramebufferBinding(this, nullptr),
       m_transformFeedbackBinding(this, nullptr),
       m_boundCopyReadBuffer(this, nullptr),
       m_boundCopyWriteBuffer(this, nullptr),
       m_boundPixelPackBuffer(this, nullptr),
       m_boundPixelUnpackBuffer(this, nullptr),
       m_boundTransformFeedbackBuffer(this, nullptr),
       m_boundUniformBuffer(this, nullptr),
       m_currentBooleanOcclusionQuery(this, nullptr),
-      m_currentTransformFeedbackPrimitivesWrittenQuery(this, nullptr) {
+      m_currentTransformFeedbackPrimitivesWrittenQuery(this, nullptr),
+      m_currentElapsedQuery(this, nullptr) {
   m_supportedInternalFormatsStorage.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
 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;
+  m_currentElapsedQuery = nullptr;
 }
 
 void WebGL2RenderingContextBase::destroyContext() {
   for (auto& callback : m_getBufferSubDataAsyncCallbacks) {
     callback->destroy();
   }
   m_getBufferSubDataAsyncCallbacks.clear();
 
   WebGLRenderingContextBase::destroyContext();
 }
 
 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_currentElapsedQuery = nullptr;
 
   GLint numCombinedTextureImageUnits = 0;
   contextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                            &numCombinedTextureImageUnits);
   m_samplerUnits.clear();
   m_samplerUnits.resize(numCombinedTextureImageUnits);
 
   m_maxTransformFeedbackSeparateAttribs = 0;
   contextGL()->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                            &m_maxTransformFeedbackSeparateAttribs);
@@ skipping 2339 matching lines @@
   if (m_currentBooleanOcclusionQuery == query) {
     contextGL()->EndQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
     m_currentBooleanOcclusionQuery = nullptr;
   }
 
   if (m_currentTransformFeedbackPrimitivesWrittenQuery == query) {
     contextGL()->EndQueryEXT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
     m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
   }
 
+  if (m_currentElapsedQuery == query) {
+    contextGL()->EndQueryEXT(m_currentElapsedQuery->getTarget());
+    m_currentElapsedQuery = nullptr;
+  }
+
   deleteObject(query);
 }
 
 GLboolean WebGL2RenderingContextBase::isQuery(WebGLQuery* query) {
   if (isContextLost() || !query)
     return 0;
 
   return contextGL()->IsQueryEXT(query->object());
 }
 
@@ skipping 30 matching lines @@
       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;
+    case GL_TIME_ELAPSED_EXT: {
+      if (!extensionEnabled(EXTDisjointTimerQueryWebGL2Name)) {
+        synthesizeGLError(GL_INVALID_ENUM, "beginQuery", "invalid target");
+        return;
+      }
+      if (m_currentElapsedQuery) {
+        synthesizeGLError(GL_INVALID_OPERATION, "beginQuery",
+                          "a query is already active for target");
+        return;
+      }
+      m_currentElapsedQuery = query;
+    } break;
     default:
       synthesizeGLError(GL_INVALID_ENUM, "beginQuery", "invalid target");
       return;
   }
 
   if (!query->getTarget())
     query->setTarget(target);
 
   contextGL()->BeginQueryEXT(target, query->object());
 }
@@ skipping 18 matching lines @@
     case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: {
       if (m_currentTransformFeedbackPrimitivesWrittenQuery) {
         m_currentTransformFeedbackPrimitivesWrittenQuery->resetCachedResult();
         m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
       } else {
         synthesizeGLError(GL_INVALID_OPERATION, "endQuery",
                           "target query is not active");
         return;
       }
     } break;
+    case GL_TIME_ELAPSED_EXT: {
+      if (!extensionEnabled(EXTDisjointTimerQueryWebGL2Name)) {
+        synthesizeGLError(GL_INVALID_ENUM, "endQuery", "invalid target");
+        return;
+      }
+      if (m_currentElapsedQuery) {
+        m_currentElapsedQuery->resetCachedResult();
+        m_currentElapsedQuery = nullptr;
+      } else {
+        synthesizeGLError(GL_INVALID_OPERATION, "endQuery",
+                          "target query is not active");
+        return;
+      }
+    } break;
     default:
       synthesizeGLError(GL_INVALID_ENUM, "endQuery", "invalid target");
       return;
   }
 
   contextGL()->EndQueryEXT(target);
 }
 
-WebGLQuery* WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname) {
+ScriptValue WebGL2RenderingContextBase::getQuery(ScriptState* scriptState,
+                                                 GLenum target,
+                                                 GLenum pname) {
   if (isContextLost())
-    return nullptr;
+    return ScriptValue::createNull(scriptState);
+
+  if (extensionEnabled(EXTDisjointTimerQueryWebGL2Name)) {
+    switch (target) {
+      case GL_TIME_ELAPSED_EXT:
+        if (pname == GL_CURRENT_QUERY && m_currentElapsedQuery.get()) {
+          return WebGLAny(scriptState, m_currentElapsedQuery.get());
+        }
+        return ScriptValue::createNull(scriptState);
+      case GL_TIMESTAMP_EXT:
+        if (pname == GL_QUERY_COUNTER_BITS_EXT) {
+          GLint value = 0;
+          contextGL()->GetQueryivEXT(target, pname, &value);
+          return WebGLAny(scriptState, value);
+        }
+        return ScriptValue::createNull(scriptState);
+    }
+  }
 
   if (pname != GL_CURRENT_QUERY) {
     synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid parameter name");
-    return nullptr;
+    return ScriptValue::createNull(scriptState);
   }
 
   switch (target) {
     case GL_ANY_SAMPLES_PASSED:
     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
       if (m_currentBooleanOcclusionQuery &&
           m_currentBooleanOcclusionQuery->getTarget() == target)
-        return m_currentBooleanOcclusionQuery;
+        return WebGLAny(scriptState, m_currentBooleanOcclusionQuery);
       break;
     case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-      return m_currentTransformFeedbackPrimitivesWrittenQuery;
+      return WebGLAny(scriptState,
+                      m_currentTransformFeedbackPrimitivesWrittenQuery);
     default:
       synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid target");
-      return nullptr;
+      return ScriptValue::createNull(scriptState);
   }
-  return nullptr;
+  return ScriptValue::createNull(scriptState);
 }
 
 ScriptValue WebGL2RenderingContextBase::getQueryParameter(
     ScriptState* scriptState,
     WebGLQuery* query,
     GLenum pname) {
   bool deleted;
   if (!query) {
     synthesizeGLError(GL_INVALID_OPERATION, "getQueryParameter",
                       "query object is null");
     return ScriptValue::createNull(scriptState);
   }
   if (!checkObjectToBeBound("getQueryParameter", query, deleted))
     return ScriptValue::createNull(scriptState);
   if (deleted) {
     synthesizeGLError(GL_INVALID_OPERATION, "getQueryParameter",
                       "attempted to access to a deleted query object");
     return ScriptValue::createNull(scriptState);
   }
 
   // Query is non-null at this point.
   if (!query->getTarget()) {
     synthesizeGLError(GL_INVALID_OPERATION, "getQueryParameter",
                       "'query' is not a query object yet, since it has't been "
                       "used by beginQuery");
     return ScriptValue::createNull(scriptState);
   }
   if (query == m_currentBooleanOcclusionQuery ||
-      query == m_currentTransformFeedbackPrimitivesWrittenQuery) {
+      query == m_currentTransformFeedbackPrimitivesWrittenQuery ||
+      query == m_currentElapsedQuery) {
     synthesizeGLError(GL_INVALID_OPERATION, "getQueryParameter",
                       "query is currently active");
     return ScriptValue::createNull(scriptState);
   }
 
   switch (pname) {
     case GL_QUERY_RESULT: {
       query->updateCachedResult(contextGL());
       return WebGLAny(scriptState, query->getQueryResult());
     }
@@ skipping 1030 matching lines @@
     case GL_UNPACK_IMAGE_HEIGHT:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_ROW_LENGTH:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_IMAGES:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_PIXELS:
       return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_ROWS:
       return getIntParameter(scriptState, pname);
+    case GL_TIMESTAMP_EXT:
+      if (extensionEnabled(EXTDisjointTimerQueryWebGL2Name)) {
+        return WebGLAny(scriptState, 0);
+      }
+      synthesizeGLError(GL_INVALID_ENUM, "getParameter",
+                        "invalid parameter name, "
+                        "EXT_disjoint_timer_query_webgl2 not enabled");
+      return ScriptValue::createNull(scriptState);

[Ken Russell (switch to Gerrit), 2016/10/21 00:18:13]

I'm not sure this is the same thing as returning the integer 0. Please make sure
the new test verifies this code path and that it checks the returned type. If it
returns null then typeof(null)=="object" where typeof(0)=="number".

[Kai Ninomiya, 2016/10/21 17:58:10]

This is the case where the given pname (GL_TIMESTAMP_EXT) is not known (because
the extension is not enabled). Isn't returning null consistent with the
following?

"If pname is not in the table above and is not one of parameter names supported
by WebGL 1.0, generates an INVALID_ENUM error and returns null."

This is also the same semantic exposed in WebGL 1 with EXT_disjoint_timer_query.
This code is sort-of copied from WebGLRenderingContextBase::getParameter.

[Ken Russell (switch to Gerrit), 2016/10/21 20:53:14]

OK, I see. Thanks. I have a related concern which I'll raise in the most recent
patch set.

+    case GL_GPU_DISJOINT_EXT:
+      if (extensionEnabled(EXTDisjointTimerQueryWebGL2Name)) {
+        return getBooleanParameter(scriptState, GL_GPU_DISJOINT_EXT);
+      }
+      synthesizeGLError(GL_INVALID_ENUM, "getParameter",
+                        "invalid parameter name, "
+                        "EXT_disjoint_timer_query_webgl2 not enabled");
+      return ScriptValue::createNull(scriptState);

[Ken Russell (switch to Gerrit), 2016/10/21 00:18:13]

Same here -- this needs to explicitly return a boolean.
typeof(false)=="boolean"; please verify this.

[Kai Ninomiya, 2016/10/21 17:58:10]

See above.

 
     default:
       return WebGLRenderingContextBase::getParameter(scriptState, pname);
   }
 }
 
 ScriptValue WebGL2RenderingContextBase::getInt64Parameter(
     ScriptState* scriptState,
     GLenum pname) {
   GLint64 value = 0;
@@ skipping 555 matching lines @@
   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_boundIndexedTransformFeedbackBuffers);
   visitor->trace(m_boundIndexedUniformBuffers);
   visitor->trace(m_currentBooleanOcclusionQuery);
   visitor->trace(m_currentTransformFeedbackPrimitivesWrittenQuery);
+  visitor->trace(m_currentElapsedQuery);
   visitor->trace(m_samplerUnits);
   visitor->trace(m_getBufferSubDataAsyncCallbacks);
   WebGLRenderingContextBase::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGL2RenderingContextBase) {
   if (isContextLost()) {
     return;
   }
 
   visitor->traceWrappers(m_transformFeedbackBinding);
   visitor->traceWrappers(m_readFramebufferBinding);
   visitor->traceWrappers(m_boundCopyReadBuffer);
   visitor->traceWrappers(m_boundCopyWriteBuffer);
   visitor->traceWrappers(m_boundPixelPackBuffer);
   visitor->traceWrappers(m_boundPixelUnpackBuffer);
   visitor->traceWrappers(m_boundTransformFeedbackBuffer);
   visitor->traceWrappers(m_boundUniformBuffer);
   for (auto& buf : m_boundIndexedTransformFeedbackBuffers) {
     visitor->traceWrappers(buf);
   }
   for (auto& buf : m_boundIndexedUniformBuffers) {
     visitor->traceWrappers(buf);
   }
   visitor->traceWrappers(m_currentBooleanOcclusionQuery);
   visitor->traceWrappers(m_currentTransformFeedbackPrimitivesWrittenQuery);
+  visitor->traceWrappers(m_currentElapsedQuery);
   for (auto& unit : m_samplerUnits) {
     visitor->traceWrappers(unit);
   }
   WebGLRenderingContextBase::traceWrappers(visitor);
 }
 
 WebGLTexture* WebGL2RenderingContextBase::validateTexture3DBinding(
     const char* functionName,
     GLenum target) {
   WebGLTexture* tex = nullptr;
@@ skipping 232 matching lines @@
   }
 
   for (auto& buf : m_boundIndexedUniformBuffers) {
     DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, buf, isolate);
   }
 
   DOMWrapperWorld::setWrapperReferencesInAllWorlds(
       wrapper, m_currentBooleanOcclusionQuery, isolate);
   DOMWrapperWorld::setWrapperReferencesInAllWorlds(
       wrapper, m_currentTransformFeedbackPrimitivesWrittenQuery, isolate);
+  DOMWrapperWorld::setWrapperReferencesInAllWorlds(
+      wrapper, m_currentElapsedQuery, isolate);
 
   for (auto& unit : m_samplerUnits) {
     DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, unit, isolate);
   }
 }
 
 WebGLImageConversion::PixelStoreParams
 WebGL2RenderingContextBase::getPackPixelStoreParams() {
   WebGLImageConversion::PixelStoreParams params;
   params.alignment = m_packAlignment;
@@ skipping 12 matching lines @@
   params.skipPixels = m_unpackSkipPixels;
   params.skipRows = m_unpackSkipRows;
   if (dimension == Tex3D) {
     params.imageHeight = m_unpackImageHeight;
     params.skipImages = m_unpackSkipImages;
   }
   return params;
 }
 
 }  // namespace blink