Only make timer queries' results available when control returns to browser.

third_party/WebKit/Source/modules/webgl/EXTDisjointTimerQuery.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 "modules/webgl/EXTDisjointTimerQuery.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
@@ skipping 79 matching lines @@
         return;
     }
 
     if (query->hasTarget() && query->target() != target) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     scoped.context()->webContext()->beginQueryEXT(target, query->object());
     query->setTarget(target);
     m_currentElapsedQuery = query;

[David Yen, 2015/10/05 17:23:16]

We also need to reset the cache results here so we don't return stale query
data.

[Ken Russell (switch to Gerrit), 2015/10/05 23:17:59]

I'm not sure about that. The ES 3.0 spec says about EndQuery: "The active query
object for |target| is updated to indicate that query results are not available,
...". This implies to me that any previous results can still be fetched even
after BeginQuery is called.

[David Yen, 2015/10/05 23:36:30]

I think you are right about when the query result should be marked as
unavailable. However looking at the spec there is another caveat here:

The error INVALID_OPERATION is generated if GetQueryObjectuivEXT is called where
<id> is the name of a currently active query object.

So the query result cannot actually be queried between a begin and end query
call. That is probably my fault when I first implemented this. We need to add a
check for "if (m_currentElapsedQuery)" in getQueryEXT() and return
GL_INVALID_OPERATION.

 }
 
 void EXTDisjointTimerQuery::endQueryEXT(GLenum target)
 {
     WebGLExtensionScopedContext scoped(this);
     if (scoped.isLost())
         return;
 
     if (target != GL_TIME_ELAPSED_EXT) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
         return;
     }
 
     if (!m_currentElapsedQuery) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     scoped.context()->webContext()->endQueryEXT(target);
+    m_currentElapsedQuery->resetCachedResult();
     m_currentElapsedQuery.clear();
 }
 
 void EXTDisjointTimerQuery::queryCounterEXT(WebGLTimerQueryEXT* query, GLenum target)
 {
     WebGLExtensionScopedContext scoped(this);
     if (scoped.isLost())
         return;
 
     if (!query || query->isDeleted() || !query->validate(0, scoped.context())) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     if (target != GL_TIMESTAMP_EXT) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
         return;
     }
 
     if (query->hasTarget() && query->target() != target) {
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     scoped.context()->webContext()->queryCounterEXT(query->object(), target);
     query->setTarget(target);
+    query->resetCachedResult();
 }
 
 ScriptValue EXTDisjointTimerQuery::getQueryEXT(ScriptState* scriptState, GLenum target, GLenum pname)
 {
     WebGLExtensionScopedContext scoped(this);
     if (scoped.isLost())
         return ScriptValue::createNull(scriptState);
 
     if (target == GL_TIMESTAMP_EXT || target == GL_TIME_ELAPSED_EXT) {
         switch (pname) {
@@ skipping 14 matching lines @@
     scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
     return ScriptValue::createNull(scriptState);
 }
 
 ScriptValue EXTDisjointTimerQuery::getQueryObjectEXT(ScriptState* scriptState, WebGLTimerQueryEXT* query, GLenum pname)
 {
     WebGLExtensionScopedContext scoped(this);
     if (scoped.isLost())
         return ScriptValue::createNull(scriptState);
 
     if (!query || query->isDeleted() || !query->validate(0, scoped.context())) {

[David Yen, 2015/10/05 23:36:30]

It looks like we can just add the m_currentElapsedQuery check in here.

[Ken Russell (switch to Gerrit), 2015/10/06 00:08:17]

Thanks. Fixed in the current patch set. Tested with
https://github.com/KhronosGroup/WebGL/pull/1255 .

         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return ScriptValue::createNull(scriptState);
     }
 
-    // TODO(kbr): Per the spec, figure out a way to only update this value once
-    // the current frame has completed rendering.
     switch (pname) {
     case GL_QUERY_RESULT_EXT: {
-        GLuint64 result = 0;
-        scoped.context()->webContext()->getQueryObjectui64vEXT(query->object(), pname, &result);
-        return WebGLAny(scriptState, result);
+        query->updateCachedResult(scoped.context()->webContext());
+        return WebGLAny(scriptState, query->getQueryResult());
     }
     case GL_QUERY_RESULT_AVAILABLE_EXT: {
-        GLuint available = 0;
-        scoped.context()->webContext()->getQueryObjectuivEXT(query->object(), pname, &available);
-        return WebGLAny(scriptState, !!available);
+        query->updateCachedResult(scoped.context()->webContext());
+        return WebGLAny(scriptState, query->isQueryResultAvailable());
     }
     default:
         scoped.context()->webContext()->synthesizeGLError(GL_INVALID_ENUM);
         break;
     }
 
     return ScriptValue::createNull(scriptState);
 }
 
 DEFINE_TRACE(EXTDisjointTimerQuery)
 {
     visitor->trace(m_currentElapsedQuery);
     WebGLExtension::trace(visitor);
 }
 
 EXTDisjointTimerQuery::EXTDisjointTimerQuery(WebGLRenderingContextBase* context)
     : WebGLExtension(context)
 {
     context->extensionsUtil()->ensureExtensionEnabled("GL_EXT_disjoint_timer_query");
 }
 
 } // namespace blink