webgl: Replace query task observer with a posted task

third_party/WebKit/Source/modules/webgl/WebGLQuery.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/WebGLQuery.h"
 
+#include "core/dom/TaskRunnerHelper.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 WebGLQuery* WebGLQuery::create(WebGL2RenderingContextBase* ctx)
 {
     return new WebGLQuery(ctx);
 }
 
 WebGLQuery::~WebGLQuery()
 {
-    unregisterTaskObserver();
-
     // See the comment in WebGLObject::detachAndDeleteObject().
     detachAndDeleteObject();
 }
 
 WebGLQuery::WebGLQuery(WebGL2RenderingContextBase* ctx)
     : WebGLSharedPlatform3DObject(ctx)
     , m_target(0)
-    , m_taskObserverRegistered(false)
     , m_canUpdateAvailability(false)
     , m_queryResultAvailable(false)
     , m_queryResult(0)
+    , m_taskRunner(TaskRunnerHelper::get(TaskType::Unthrottled, &ctx->canvas()->document())->clone())
+    , m_weakFactory(this)

[Ken Russell (switch to Gerrit), 2016/09/16 23:12:39]

As vmiura@ points out, I think the use of WeakPtrs pointing to this Oilpan-GC'd
type introduces the same basic problem as before -- that there is a
non-Oilpan-aware pointer to this GC'd object. (base::WeakPtrFactory and
consequently WTF::WeakPtrFactory doesn't know about Oilpan's GC.) There was an
attempt in the earlier code to unregister the task observer in the destructor,
but as we discovered, that violated some of Oilpan's invariants, since the
destructor wasn't called before poisoning the page the object lived on.

I think the safe way to handle this would be to have a separate, C-heap
allocated object which contains a WeakMember pointing back to this one, and use
that object in the postTask call. I'm not sure how the lifetime of that object
should be managed though. What do you think?

Alternatively, as Victor points out, we could cause these objects to be eagerly
finalized, but apparently that adds overhead so perhaps we should find another
solution.

 {
     GLuint query;
     ctx->contextGL()->GenQueriesEXT(1, &query);
     setObject(query);
 }
 
 void WebGLQuery::setTarget(GLenum target)
 {
     ASSERT(object());
     ASSERT(!m_target);
     m_target = target;
 }
 
 void WebGLQuery::deleteObjectImpl(gpu::gles2::GLES2Interface* gl)
 {
     gl->DeleteQueriesEXT(1, &m_object);
     m_object = 0;
 }
 
 void WebGLQuery::resetCachedResult()
 {
     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();
+    scheduleAllowAvailabilityUpdate();
 }
 
 void WebGLQuery::updateCachedResult(gpu::gles2::GLES2Interface* gl)
 {
     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;
     gl->GetQueryObjectuivEXT(object(), GL_QUERY_RESULT_AVAILABLE_EXT, &available);
     m_queryResultAvailable = !!available;
     if (m_queryResultAvailable) {
         GLuint result = 0;
         gl->GetQueryObjectuivEXT(object(), GL_QUERY_RESULT_EXT, &result);
         m_queryResult = result;
-        unregisterTaskObserver();
+        m_weakFactory.revokeAll();
+    } else {
+        scheduleAllowAvailabilityUpdate();
     }
 }
 
 bool WebGLQuery::isQueryResultAvailable()
 {
     return m_queryResultAvailable;
 }
 
 GLuint WebGLQuery::getQueryResult()
 {
     return m_queryResult;
 }
 
-void WebGLQuery::registerTaskObserver()
+void WebGLQuery::scheduleAllowAvailabilityUpdate()
 {
-    if (!m_taskObserverRegistered) {
-        m_taskObserverRegistered = true;
-        Platform::current()->currentThread()->addTaskObserver(this);
-    }
+    if (m_weakFactory.hasWeakPtrs())
+        return;
+    m_taskRunner->postTask(BLINK_FROM_HERE, WTF::bind(&WebGLQuery::allowAvailabilityUpdate, m_weakFactory.createWeakPtr()));
 }
 
-void WebGLQuery::unregisterTaskObserver()
-{
-    if (m_taskObserverRegistered) {
-        m_taskObserverRegistered = false;
-        Platform::current()->currentThread()->removeTaskObserver(this);
-    }
-}
-
-void WebGLQuery::didProcessTask()
+void WebGLQuery::allowAvailabilityUpdate()
 {
     m_canUpdateAvailability = true;
 }
 
 } // namespace blink