Move hasPendingActivity from ActiveDOMObject to ScriptWrappable

third_party/WebKit/Source/bindings/core/v8/V8GCController.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "bindings/core/v8/V8GCController.h"
 
+#include "bindings/core/v8/NPV8Object.h"
 #include "bindings/core/v8/RetainedDOMInfo.h"
 #include "bindings/core/v8/V8AbstractEventListener.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8MutationObserver.h"
 #include "bindings/core/v8/V8Node.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/WrapperTypeInfo.h"
 #include "core/dom/Attr.h"
 #include "core/dom/Document.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/TemplateContentDocumentFragment.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLTemplateElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/svg/SVGElement.h"
+#include "platform/Histogram.h"
 #include "platform/TraceEvent.h"
 #include "wtf/Partitions.h"
 #include "wtf/Vector.h"
 #include <algorithm>
 
 namespace blink {
 
 // FIXME: This should use opaque GC roots.
 static void addReferencesForNodeWithEventListeners(v8::Isolate* isolate, Node* node, const v8::Persistent<v8::Object>& wrapper)
 {
@@ skipping 53 matching lines @@
         // MinorGC does not collect objects because it may be expensive to
         // update references during minorGC
         if (classId == WrapperTypeInfo::ObjectClassId) {
             v8::Persistent<v8::Object>::Cast(*value).MarkActive();
             return;
         }
 
         v8::Local<v8::Object> wrapper = v8::Local<v8::Object>::New(m_isolate, v8::Persistent<v8::Object>::Cast(*value));
         ASSERT(V8DOMWrapper::hasInternalFieldsSet(wrapper));
         const WrapperTypeInfo* type = toWrapperTypeInfo(wrapper);
-        ActiveDOMObject* activeDOMObject = type->toActiveDOMObject(wrapper);
-        if (activeDOMObject && activeDOMObject->hasPendingActivity()) {
-            v8::Persistent<v8::Object>::Cast(*value).MarkActive();
+        if (type != npObjectTypeInfo() && toScriptWrappable(wrapper)->hasPendingActivity())
             return;
-        }
 
         if (classId == WrapperTypeInfo::NodeClassId) {
             ASSERT(V8Node::hasInstance(wrapper, m_isolate));
             Node* node = V8Node::toImpl(wrapper);
             if (node->hasEventListeners()) {
                 v8::Persistent<v8::Object>::Cast(*value).MarkActive();
                 return;
             }
             // FIXME: Remove the special handling for image elements.
             // The same special handling is in V8GCController::opaqueRootForGC().
@@ skipping 33 matching lines @@
             return;
 
         v8::Local<v8::Object> wrapper = v8::Local<v8::Object>::New(m_isolate, v8::Persistent<v8::Object>::Cast(*value));
         ASSERT(V8DOMWrapper::hasInternalFieldsSet(wrapper));
 
         if (value->IsIndependent())
             return;
 
         const WrapperTypeInfo* type = toWrapperTypeInfo(wrapper);
 
-        ActiveDOMObject* activeDOMObject = type->toActiveDOMObject(wrapper);
-        if (activeDOMObject && activeDOMObject->hasPendingActivity()) {
+        if (type != npObjectTypeInfo() && toScriptWrappable(wrapper)->hasPendingActivity()) {
             m_isolate->SetObjectGroupId(*value, liveRootId());
             ++m_domObjectsWithPendingActivity;
         }
 
         if (classId == WrapperTypeInfo::NodeClassId) {
             ASSERT(V8Node::hasInstance(wrapper, m_isolate));
             Node* node = V8Node::toImpl(wrapper);
             if (node->hasEventListeners())
                 addReferencesForNodeWithEventListeners(m_isolate, node, v8::Persistent<v8::Object>::Cast(*value));
             Node* root = V8GCController::opaqueRootForGC(m_isolate, node);
@@ skipping 261 matching lines @@
 private:
     Visitor* m_visitor;
 };
 
 void V8GCController::traceDOMWrappers(v8::Isolate* isolate, Visitor* visitor)
 {
     DOMWrapperTracer tracer(visitor);
     isolate->VisitHandlesWithClassIds(&tracer);
 }
 
+class PendingActivityVisitor : public v8::PersistentHandleVisitor {
+public:
+    explicit PendingActivityVisitor(ExecutionContext* executionContext)
+        : m_executionContext(executionContext)
+        , m_pendingActivityFound(false)
+    {
+    }
+
+    void VisitPersistentHandle(v8::Persistent<v8::Value>* value, uint16_t classId) override
+    {
+        // If we have already found any wrapper that has a pending activity,
+        // we don't need to check other wrappers.
+        if (m_pendingActivityFound)
+            return;
+
+        if (classId != WrapperTypeInfo::NodeClassId && classId != WrapperTypeInfo::ObjectClassId)
+            return;
+
+        const v8::Persistent<v8::Object>& wrapper = v8::Persistent<v8::Object>::Cast(*value);
+        const WrapperTypeInfo* type = toWrapperTypeInfo(wrapper);
+        // The ExecutionContext check is heavy, so it should be done at the last.
+        if (type != npObjectTypeInfo()
+            && toScriptWrappable(wrapper)->hasPendingActivity()
+            // TODO(haraken): Currently we don't have a way to get a creation
+            // context from a wrapper. We should implement the way and enable
+            // the following condition.
+            //
+            // This condition affects only compositor workers, where one isolate
+            // is shared by multiple workers. If we don't have the condition,
+            // a worker object for a compositor worker doesn't get collected
+            // until all compositor workers in the same isolate lose pending
+            // activities. In other words, not having the condition delays
+            // destruction of a worker object of a compositor worker.
+            //
+            /* && toExecutionContext(wrapper->creationContext()) == m_executionContext */

[haraken, 2016/02/08 05:42:45]

This needs a new V8 API (v8::Object::CreationContext), but the V8 team doesn't
want to introduce the API because we're deprecating CreationContext. Our plan is
to deprecate CreationContext from V8 by improving V8 binding so that each V8
wrapper understands the context from which the wrapper has been created.
However, it needs a substantial amount of work. So I'd like to land this CL with
TODO at the moment.

+            )
+            m_pendingActivityFound = true;
+    }
+
+    bool pendingActivityFound() const { return m_pendingActivityFound; }
+
+private:
+    RawPtrWillBePersistent<ExecutionContext> m_executionContext;
+    bool m_pendingActivityFound;
+};
+
+bool V8GCController::hasPendingActivity(ExecutionContext* executionContext)
+{
+    // V8GCController::hasPendingActivity is used only when a worker checks if
+    // the worker contains any wrapper that has pending activities.
+    ASSERT(!isMainThread());
+
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, scanPendingActivityHistogram, new CustomCountHistogram("Blink.ScanPendingActivityHistogram", 1, 1000, 50));
+    double startTime = WTF::currentTimeMS();
+    PendingActivityVisitor visitor(executionContext);
+    toIsolate(executionContext)->VisitHandlesWithClassIds(&visitor);
+    scanPendingActivityHistogram.count(WTF::currentTimeMS() - startTime);

[Ilya Sherman, 2016/02/09 22:07:00]

Hrm, you seem to be passing a double into a function that expects an int.  Does
this not generate a compiler error -- and if not, what am I missing?

+    return visitor.pendingActivityFound();
+}
+
 } // namespace blink