Make customElements.define faster

third_party/WebKit/Source/bindings/core/v8/TraceWrapperReference.md

 # Wrapper Tracing Reference
 
 This document describes wrapper tracing and how its API is supposed to be used.
 
 [TOC]
 
 ## Quickstart guide
 
 Wrapper tracing is used to represent reachability across V8 and Blink. The
 following checklist highlights the modifications needed to make a class
 participate in wrapper tracing.
 
 1. Make sure that objects participating in tracing either inherit from
 ``ScriptWrappable`` (if they can reference wrappers) or ``TraceWrapperBase``
 (transitively holding wrappers alive).
 2. Use ``TraceWrapperMember<T>`` to annotate fields that need to be followed to
 find other wrappers that this object should keep alive.
 3. Use ``TraceWrapperV8Reference<T>`` to annotate references to V8 that this
 object should keep alive.
 4. Declare a method to trace other wrappers using
 ``DECLARE_VIRTUAL_TRACE_WRAPPERS()``.
 5. Define the method using ``DEFINE_TRACE_WRAPPERS(ClassName)``.
 6. Trace all fields that received a wrapper tracing type in (1) and (2) using
-``visitor->traceWrapers(<m_field>)`` in the body of ``DEFINE_TRACE_WRAPPERS``.
+``visitor->TraceWrappers(<m_field>)`` in the body of ``DEFINE_TRACE_WRAPPERS``.

[Michael Lippautz, 2017/04/19 08:49:12]

Oh boy :)

Thanks, we could also do this in a separate CL if you like.

 
 The following example illustrates these steps:
 
 ```c++
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/core/v8/TraceWrapperMember.h"
 #include "bindings/core/v8/TraceWrapperV8Reference.h"
 
 class SomeDOMObject : public ScriptWrappable {          // (1)
  public:
   DECLARE_VIRTUAL_TRACE_WRAPPERS();                     // (4)
 
  private:
   TraceWrapperMember<OtherWrappable> m_otherWrappable;  // (2)
   Member<NonWrappable> m_nonWrappable;
   TraceWrapperV8Reference<v8::Value> m_v8object;        // (3)
   // ...
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {                  // (5)
-  visitor->traceWrappers(m_otherWrappable);             // (6)
-  visitor->traceWrappers(m_v8object);                   // (6)
+  visitor->TraceWrappers(m_otherWrappable);             // (6)
+  visitor->TraceWrappers(m_v8object);                   // (6)
 }
 ```
 
 For more in-depth information and how to deal with corner cases continue on reading.
 
 ## Background
 
 Blink and V8 need to cooperate to collect JavaScript *wrappers*. Each V8
 *wrapper* object (*W*) in JavaScript is assigned a C++ *DOM object* (*D*) in
 Blink. A single C++ *DOM object* can hold onto one or many *wrapper* objects.
@@ skipping 18 matching lines @@
 [object-grouping-slides]: https://docs.google.com/presentation/d/1I6leiRm0ysSTqy7QWh33Gfp7_y4ngygyM2tDAqdF0fI/
 [oilpan-docs]: https://chromium.googlesource.com/chromium/src/+/master/third_party/WebKit/Source/platform/heap/BlinkGCAPIReference.md
 
 ## Basic usage
 
 The annotations that are required can be found in the following header files.
 Pick the header file depending on what types are needed.
 
 ```c++
 #include "bindings/core/v8/ScriptWrappable.h"
-#include "bindings/core/v8/TraceWrapperBase.h"
 #include "bindings/core/v8/TraceWrapperMember.h"
 #include "bindings/core/v8/TraceWrapperV8Reference.h"
 ```
 
 The following example will guide through the modifications that are needed to
 adjust a given class ``SomeDOMObject`` to participate in wrapper tracing.
 
 ```c++
 class SomeDOMObject : public ScriptWrappable {
   // ...
@@ skipping 23 matching lines @@
 class SomeDOMObject : public ScriptWrappable {
  public:
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
 
  private:
   Member<OtherWrappable> m_otherWrappable;
   Member<NonWrappable> m_nonWrappable;
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {
-  visitor->traceWrappers(m_otherWrappable);
+  visitor->TraceWrappers(m_otherWrappable);
 }
 ```
 
 
 Blink and V8 implement *incremental* wrapper tracing, which means that marking
 can be interleaved with JavaScript or even DOM operations. This poses a
 challenge, because already marked objects will not be considered again if they
 are reached through some other path.
 
 For example, consider an object ``A`` that has already been marked and a write
@@ skipping 12 matching lines @@
  public:
   SomeDOMObject() : m_otherWrappable(this, nullptr) {}
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
 
  private:
   TraceWrapperMember<OtherWrappable> m_otherWrappable;
   Member<NonWrappable> m_nonWrappable;
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {
-  visitor->traceWrappers(m_otherWrappable);
+  visitor->TraceWrappers(m_otherWrappable);
 }
 ```
 
 ``TraceWrapperMember`` makes sure that any write to ``m_otherWrappable`` will
 consider doing a write barrier. Using the proper type, the write barrier is
 correct by construction, i.e., it will never be missed.
 
 ## Heap collections
 
 The proper type usage for collections, e.g. ``HeapVector`` looks like the
 following.
 
 ```c++
 class SomeDOMObject : public ScriptWrappable {
  public:
   // ...
   void AppendNewValue(OtherWrappable* newValue);
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
 
  private:
   HeapVector<TraceWrapperMember<OtherWrappable>> m_otherWrappables;
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {
   for (auto other : m_otherWrappables)
-    visitor->traceWrappers(other);
+    visitor->TraceWrappers(other);
 }
 ```
 
 Note that this is different to Oilpan which can just trace the whole collection.
 Whenever an element is added through ``append()`` the value needs to be
 constructed using ``TraceWrapperMember``, e.g.
 
 ```c++
 void SomeDOMObject::AppendNewValue(OtherWrappable* newValue) {
   m_otherWrappables.append(TraceWrapperMember(this, newValue));
@@ skipping 20 matching lines @@
     m_otherWrappables[i] = other;
   }
 
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
  private:
   HeapVector<TraceWrapperMember<OtherWrappable>> m_otherWrappables;
 };
 
 DEFINE_TRACE_WRAPPERS(SomeDOMObject) {
   for (auto other : m_otherWrappables)
-    visitor->traceWrappers(other);
+    visitor->TraceWrappers(other);
 }
 ```
 
 In this example, the compiler will not warn you on
 ``m_otherWrappables[i] = other``, but an assertion will throw at runtime as long
 as there exists a test covering that branch.
 
 The correct assignment looks like
 
 ```c++
@@ skipping 39 matching lines @@
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
  private:
   Member<OtherWrappable>> m_otherWrappable;
 };
 
 DEFINE_TRACE_WRAPPERS(ManualWrappable) {
   for (auto other : m_otherWrappables)
     visitor->traceWrappersWithManualWriteBarrier(other);
 }
 ```