Introduce infrastructure for tracing ScriptWrappables.

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

+// Copyright 2016 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 "bindings/core/v8/ScriptWrappableHeapTracer.h"
+
+#include "bindings/core/v8/ActiveScriptWrappable.h"
+#include "bindings/core/v8/DOMDataStore.h"
+#include "bindings/core/v8/ScriptWrappable.h"
+#include "bindings/core/v8/ScriptWrappableVisitor.h"
+#include "bindings/core/v8/WrapperTypeInfo.h"
+#include "platform/heap/HeapPage.h"
+
+namespace blink {
+
+ScriptWrappableHeapTracer::~ScriptWrappableHeapTracer()
+{
+}
+
+void ScriptWrappableHeapTracer::TraceRoots(v8::Isolate* isolate)
+{
+    m_tracingInProgress = true;
+    ScriptWrappableVisitor visitor(isolate, this);
+    ActiveScriptWrappable::traceActiveScriptWrappables(&visitor);
+}
+
+void ScriptWrappableHeapTracer::AddHeaderToUnmark(HeapObjectHeader* header)
+{
+    m_headersToUnmark.push_back(header);
+}
+
+void ScriptWrappableHeapTracer::ClearTracingMarks(v8::Isolate* isolate)

[haraken, 2016/04/18 04:35:42]

TraceRoots => TracePrologue
ClearTracingMarks => TraceEpilogue

?

[Marcel Hlopko, 2016/04/18 11:45:35]

I like it, I uploaded cl for the v8 side, after landing I'll change this one
accordingly.

+{
+    for (auto header : m_headersToUnmark)
+        header->unmarkWrappable();
+
+    m_headersToUnmark.clear();
+    m_tracingInProgress = false;
+}
+
+void ScriptWrappableHeapTracer::TraceWrappableFrom(v8::Isolate* isolate, const std::vector<std::pair<void*, void*>>& internalFieldsOfPotentialWrappers)

[haraken, 2016/04/18 04:35:42]

std::vector is not allowed in Blink.

Can we use a visitor pattern (e.g., v8::PersistentHandleVisitor) and avoid
passing std::vector to Blink?

[Marcel Hlopko, 2016/04/18 11:45:35]

Leaving as is after the discussion.

+{
+    ASSERT(m_tracingInProgress);
+    for (auto pair : internalFieldsOfPotentialWrappers) {
+        TraceWrappableFrom(isolate, pair);
+    }
+}
+
+
+void ScriptWrappableHeapTracer::TraceWrappableFrom(v8::Isolate* isolate, std::pair<void*, void*> internalFields)
+{
+    if (!internalFields.first)
+        return;
+    if (reinterpret_cast<intptr_t>(internalFields.first) % 2 == 1)
+        ASSERT_NOT_REACHED();

[haraken, 2016/04/18 04:35:42]

Then we can encapsulate this mysterious check in the V8 side.

[Marcel Hlopko, 2016/04/18 11:45:35]

Agreed, moved.

+    if (reinterpret_cast<WrapperTypeInfo*>(internalFields.first)->ginEmbedder
+        != gin::GinEmbedder::kEmbedderBlink)
+        return;
+
+    ScriptWrappable* scriptWrappable = reinterpret_cast<ScriptWrappable*>(
+        internalFields.second);
+    uint16_t classId = scriptWrappable->wrapperTypeInfo()->wrapperClassId;
+    if (classId != WrapperTypeInfo::NodeClassId

[haraken, 2016/04/18 04:35:41]

Actually I want to ask V8 to pass in the class ID to Blink so that Blink just
needs to check the class ID.

In other words, I want to design the ScriptWrappableHeapTracer in the same
manner as the v8::PersistentHandleVisitor.

[Marcel Hlopko, 2016/04/18 11:45:35]

I'm afraid that getting class id from a wrapper is non trivial and "not worth
it" (I'm not hitting global handles at all, and class id is a field of
GlobalHandles::Node).

+        && classId != WrapperTypeInfo::ObjectClassId) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    ScriptWrappableVisitor visitor(isolate, this);
+    visitor.traceWrappers(scriptWrappable);
+}
+
+void ScriptWrappableHeapTracer::TraceWrappableFrom(v8::Isolate* isolate, v8::Persistent<v8::Object>* handle)
+{
+    ScriptWrappable* scriptWrappable = toScriptWrappable(*handle);
+    uint16_t classId = scriptWrappable->wrapperTypeInfo()->wrapperClassId;
+    if (classId != WrapperTypeInfo::NodeClassId
+        && classId != WrapperTypeInfo::ObjectClassId) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    ScriptWrappableVisitor visitor(isolate, this);
+    visitor.traceWrappers(scriptWrappable);
+}
+
+void ScriptWrappableHeapTracer::markWrapper(const v8::Persistent<v8::Object>& handle, v8::Isolate* isolate)
+{
+    handle.RegisterExternalReference(isolate);
+}
+
+void ScriptWrappableHeapTracer::markWrapper(const ScriptWrappable* scriptWrappable, v8::Isolate* isolate)

[haraken, 2016/04/18 04:35:42]

markWrapper => markWrappersInAllWorlds ?

[Marcel Hlopko, 2016/04/18 11:45:35]

Done.

+{
+    ExternalReferenceRegisteringVisitor visitor(
+        const_cast<ScriptWrappable*>(scriptWrappable),
+        isolate);
+    DOMWrapperWorld::visitAllWorldsInMainThread(visitor);

[haraken, 2016/04/18 04:35:42]

visitAllWorldsInMainThread doesn't much make sense because this tracing
mechanism should work for worker threads as well.

Also using a visitor pattern here might be a bit overkilling. We can probably
just introduce DOMWrapperWorld::markWrappersInAllWorlds(ScriptWrappable*), which
is responsible for marking all wrappers in both main world and isolated worlds?

[Marcel Hlopko, 2016/04/18 11:45:35]

Agreed, updated the code accordingly.

+}
+
+void ScriptWrappableHeapTracer::ExternalReferenceRegisteringVisitor::visit(DOMWrapperWorld& world)
+{
+    DOMDataStore& dataStore = world.domDataStore();
+    if (dataStore.containsWrapper(m_scriptWrappable))
+        dataStore.markWrapper(m_scriptWrappable, m_isolate);

[haraken, 2016/04/18 04:35:41]

And you can call this in
DOMWrapperWorld::markWrappersInAllWorlds(ScriptWrappable*).

Also add a TODO and mention that we should avoid tracing all wrappers in
isolated worlds. (Actually I'm a bit afraid of the performance overhead but
let's worry about the details later :-)

[Marcel Hlopko, 2016/04/18 11:45:35]

Fixed and TODO added. I worry about the performance too, tracing worlds
individually is for sure on the roadmap.

+}
+
+}
+