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);

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

Is returning null here, rather than a boolean, correct? Does an error need to be
signaled?

[Kai Ninomiya, 2016/10/24 20:00:30]

Done.

+      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);

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

Same here. Does an error need to be raised?

[Kai Ninomiya, 2016/10/24 20:00:30]

Done.

+    }
+  }
 
   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);
+    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);
 
     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