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

third_party/WebKit/Source/modules/webgl/WebGLTimerQueryEXT.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/WebGLTimerQueryEXT.h"
 
 #include "modules/webgl/WebGLRenderingContextBase.h"
+#include "public/platform/Platform.h"
 
 namespace blink {
 
 WebGLTimerQueryEXT* WebGLTimerQueryEXT::create(WebGLRenderingContextBase* ctx)
 {
     return new WebGLTimerQueryEXT(ctx);
 }
 
 WebGLTimerQueryEXT::~WebGLTimerQueryEXT()
 {
+    unregisterTaskObserver();
+
     // See the comment in WebGLObject::detachAndDeleteObject().
     detachAndDeleteObject();
 }
 
 WebGLTimerQueryEXT::WebGLTimerQueryEXT(WebGLRenderingContextBase* ctx)
     : WebGLContextObject(ctx)
     , m_target(0)
     , m_queryId(0)
+    , m_taskObserverRegistered(false)
+    , m_canUpdateAvailability(false)
+    , m_queryResultAvailable(false)
+    , m_queryResult(0)
 {
     m_queryId = context()->webContext()->createQueryEXT();
 }
 
+void WebGLTimerQueryEXT::resetCachedResult()

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

We also need to reset the cache results when beginning a query but not register
the task observer, perhaps we should make register task observer function
public? We can rename the function to something more API friendly such as
"BeginTrackingQuery" or something.

+{
+    m_canUpdateAvailability = false;
+    m_queryResultAvailable = false;
+    m_queryResult = 0;
+    // When this is called, the implication is that we should start
+    // keeping track of whether we can update the cached availability
+    // and result.
+    registerTaskObserver();
+}
+
+void WebGLTimerQueryEXT::updateCachedResult(WebGraphicsContext3D* ctx)
+{
+    if (m_queryResultAvailable)
+        return;
+
+    if (!m_canUpdateAvailability)
+        return;
+
+    if (!hasTarget())
+        return;
+
+    // We can only update the cached result when control returns to the browser.
+    m_canUpdateAvailability = false;
+    GLuint available = 0;
+    ctx->getQueryObjectuivEXT(object(), GL_QUERY_RESULT_AVAILABLE_EXT, &available);
+    m_queryResultAvailable = !!available;
+    if (m_queryResultAvailable) {
+        GLuint64 result = 0;
+        ctx->getQueryObjectui64vEXT(object(), GL_QUERY_RESULT_EXT, &result);
+        m_queryResult = result;
+        unregisterTaskObserver();
+    }
+}
+
+bool WebGLTimerQueryEXT::isQueryResultAvailable()
+{
+    return m_queryResultAvailable;
+}
+
+GLuint64 WebGLTimerQueryEXT::getQueryResult()
+{
+    return m_queryResult;
+}
+
 void WebGLTimerQueryEXT::deleteObjectImpl(WebGraphicsContext3D* context3d)
 {
     context3d->deleteQueryEXT(m_queryId);
     m_queryId = 0;
 }
 
+void WebGLTimerQueryEXT::registerTaskObserver()
+{
+    if (!m_taskObserverRegistered) {
+        m_taskObserverRegistered = true;
+        Platform::current()->currentThread()->addTaskObserver(this);
+    }
+}
+
+void WebGLTimerQueryEXT::unregisterTaskObserver()
+{
+    if (m_taskObserverRegistered) {
+        m_taskObserverRegistered = false;
+        Platform::current()->currentThread()->removeTaskObserver(this);
+    }
+}
+
+void WebGLTimerQueryEXT::didProcessTask()
+{
+    m_canUpdateAvailability = true;
+}
+
 } // namespace blink