[NotForCommit] inline ensureMarked.

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 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 2274 matching lines @@
 struct GCInfoTrait<HeapLinkedHashSet<T, U, V> > : public GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity, typename U>
 struct GCInfoTrait<HeapListHashSet<T, inlineCapacity, U> > : public GCInfoTrait<ListHashSet<T, inlineCapacity, U, HeapListHashSetAllocator<T, inlineCapacity> > > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity> > : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity> > : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator> > { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V> > : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator> > { };
 
+static inline bool objectInTerminatingThreadHeap(const void* objectPointer)
+{
+    BaseHeapPage* page = pageFromObject(objectPointer);
+    ASSERT(!page->orphaned());
+    // When doing a thread local GC, the marker checks if
+    // the object resides in another thread's heap. The
+    // object should not be traced, if it does.
+    return page->terminating();
+}
+
+NO_SANITIZE_ADDRESS inline
+void HeapObjectHeader::mark()
+{
+    checkHeader();
+    ASSERT(!isMarked());
+    m_size = m_size | markBitMask;
+}
+
+NO_SANITIZE_ADDRESS inline
+bool HeapObjectHeader::isMarked() const
+{
+    checkHeader();
+    return m_size & markBitMask;
+}
+
+inline
+HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload)
+{
+    Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
+    HeapObjectHeader* header =
+        reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
+    return header;
+}
+
+inline
+GeneralHeapObjectHeader* GeneralHeapObjectHeader::fromPayload(const void* payload)
+{
+    Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
+    GeneralHeapObjectHeader* header =
+        reinterpret_cast<GeneralHeapObjectHeader*>(addr - sizeof(GeneralHeapObjectHeader));
+    return header;
+}
+
+    inline bool Visitor::ensureMarked(const void* objectPointer)
+    {
+      (void)m_mode;
+        if (!objectPointer)
+            return false;
+        // if (UNLIKELY(m_mode && !objectInTerminatingThreadHeap(objectPointer)))
+        //     return false;
+//#if ENABLE(ASSERT)
+//        if (isMarked(objectPointer))
+//            return false;
+//
+//        markNoTracing(objectPointer);
+//#else
+        // Inline what the above markNoTracing() call expands to,
+        // so as to make sure that we do get all the benefits.
+        GeneralHeapObjectHeader* header =
+            GeneralHeapObjectHeader::fromPayload(objectPointer);
+        if (header->isMarked())
+            return false;
+        header->mark();
+// #endif
+        return true;
+    }
+
+        // if (UNLIKELY(m_mode && !objectInTerminatingThreadHeap(objectPointer))) 
+        //     return false;                                                                       
+#define DEFINE_ENSURE_MARKED_METHOD(Type)                                                       \
+    inline bool Visitor::ensureMarked(const Type* objectPointer) \
+    {                                                                                           \
+        if (!objectPointer)                                                                     \
+            return false;                                                                       \
+        HeapObjectHeader* header =                                                              \
+            HeapObjectHeader::fromPayload(objectPointer);                                       \
+        if (header->isMarked())                                                                 \
+            return false;                                                                       \
+        header->mark();                                                                         \
+        return true;                                                                            \
+    }
+    FOR_EACH_TYPED_HEAP(DEFINE_ENSURE_MARKED_METHOD)
+#undef DEFINE_ENSURE_MARKED_METHOD
+
 } // namespace blink
 
 #endif // Heap_h