[wrapper-tracing] Remove unnecessary barrier

third_party/WebKit/Source/bindings/core/v8/TraceWrapperMember.h

 // 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.
 
 #ifndef TraceWrapperMember_h
 #define TraceWrapperMember_h
 
 #include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "platform/heap/HeapAllocator.h"
 
@@ skipping 10 matching lines @@
  */
 template <class T>
 class TraceWrapperMember : public Member<T> {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   TraceWrapperMember(void* parent, T* raw) : Member<T>(raw), m_parent(parent) {
 #if DCHECK_IS_ON()
     DCHECK(!m_parent || HeapObjectHeader::fromPayload(m_parent)->checkHeader());
 #endif
-    ScriptWrappableVisitor::writeBarrier(m_parent, raw);
+    // We don't require a write barrier here as TraceWrapperMember is used for
+    // the following scenarios:
+    // - Initial initialization: The write barrier will not fire as the parent
+    //   is initially white.

[haraken, 2016/12/12 01:02:07]

To guarantee this fact, you need to guarantee that an incremental marking step
does not happen during a constructor, right?

class A : public TraceWrapperBase {
  A() : m_x(new X), // If this triggers an incremental marking step,
        m_y(new Y)  // The parent object (=A's object we're constructing now) is
marked as black at this point.
  { }
  Member<X> m_x;
  TraceWrapperMember<Y> m_y;
};

[Michael Lippautz, 2016/12/12 08:18:57]

We (still) cannot handle this case :) We cannot mark during a ctor call as we
cannot tell the initialized from the uninitialized parts apart. 

The question that still remains is how we can enforce this on non-mixin cases. 

+    // - Wrapping when inserting into a container: The write barrier will fire
+    //   upon establishing the move into the container.
+    // - Assignment to a field: The regular assignment operator will fire the
+    //   write barrier.
+    // Note that support for black allocation would require a barrier here.

[haraken, 2016/12/12 08:44:13]

Can we add a dcheck to check if m_parent is a white object?

[Michael Lippautz, 2016/12/12 11:42:27]

Unfortunately not, as we use this type also as a wrapper type when we insert
into a container. We use the type there to avoid forgetting the barrier.

E.g.
m_vector.append(TraceWrapperMember<SomeType>(this, newValue);
                ^^^^^^^^^^^^^^^^^^
                'this' might already be black here

We delay the barrier until we actually append into the backingstore at which
point the copy ctor will fire the barrier.

   }
   TraceWrapperMember(WTF::HashTableDeletedValueType x)
       : Member<T>(x), m_parent(nullptr) {}
 
   /**
    * Copying a TraceWrapperMember means that its backpointer will also be
    * copied.
    */
   TraceWrapperMember(const TraceWrapperMember& other) { *this = other; }
 
@@ skipping 86 matching lines @@
   b.clear();
   b.reserveCapacity(temp.size());
   for (auto item : temp) {
     b.push_back(item.get());
   }
 }
 
 }  // namespace blink
 
 #endif  // TraceWrapperMember_h