Revert "heap: Enable concurrent marking for HashTable based collections"

This reverts commit 2f69de56.

Reason for revert: quick resolution to issue 1059655

Original change's description:
> heap: Enable concurrent marking for HashTable based collections
> 
> All known data races in HashTable based collections have been resolved.
> 
> Bug: 986235
> Change-Id: Ia7a22d707aaaea1ab3ebc70c47da0876fc426aa9
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2078617
> Reviewed-by: Kentaro Hara <haraken@chromium.org>
> Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
> Commit-Queue: Omer Katz <omerkatz@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#746694}

TBR=haraken@chromium.org,mlippautz@chromium.org,omerkatz@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 986235
Change-Id: Ia3e3f4ef5dd20c4826b3a8a96adc33c3401e5eb9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2120477Reviewed-by: Omer Katz <omerkatz@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Omer Katz <omerkatz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#753359}

third_party/blink/renderer/platform/heap/collection_support/heap_hash_table_backing.h

@@ -118,6 +118,9 @@ struct TraceTrait<HeapHashTableBacking<Table>> {
 
   template <WTF::WeakHandlingFlag WeakHandling = WTF::kNoWeakHandling>
   static void Trace(Visitor* visitor, const void* self) {
+    if (visitor->ConcurrentTracingBailOut({self, &Trace}))
+      return;
+
     static_assert(WTF::IsTraceableInCollectionTrait<Traits>::value ||
                       WTF::IsWeak<ValueType>::value,
                   "T should not be traced");

third_party/blink/renderer/platform/wtf/hash_table.h

@@ -2150,6 +2150,16 @@ template <typename VisitorDispatcher, typename A>
 std::enable_if_t<A::kIsGarbageCollected>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::
     Trace(VisitorDispatcher visitor) const {
+  // bail out for concurrent marking
+  if (visitor->ConcurrentTracingBailOut(
+          {this, [](blink::Visitor* visitor, const void* object) {
+             reinterpret_cast<
+                 const HashTable<Key, Value, Extractor, HashFunctions, Traits,
+                                 KeyTraits, Allocator>*>(object)
+                 ->Trace(visitor);
+           }}))
+    return;
+
   static_assert(WTF::IsWeak<ValueType>::value ||
                     IsTraceableInCollectionTrait<Traits>::value,
                 "Value should not be traced");

third_party/blink/renderer/platform/wtf/linked_hash_set.h

@@ -355,6 +355,15 @@ class LinkedHashSet {
 
   template <typename VisitorDispatcher>
   void Trace(VisitorDispatcher visitor) const {
+    if (visitor->ConcurrentTracingBailOut(
+            {this, [](blink::Visitor* visitor, const void* object) {
+               reinterpret_cast<const LinkedHashSet<ValueArg, HashFunctions,
+                                                    TraitsArg, Allocator>*>(
+                   object)
+                   ->Trace(visitor);
+             }}))
+      return;
+
     impl_.Trace(visitor);
     // Should the underlying table be moved by GC, register a callback
     // that fixes up the interior pointers that the (Heap)LinkedHashSet keeps.

third_party/blink/renderer/platform/wtf/list_hash_set.h

@@ -517,6 +517,14 @@ class ListHashSetNode : public ListHashSetNodeBase<ValueArg, AllocatorArg> {
   template <typename VisitorDispatcher, typename A = NodeAllocator>
   std::enable_if_t<A::kIsGarbageCollected> Trace(
       VisitorDispatcher visitor) const {
+    if (visitor->ConcurrentTracingBailOut(
+            {this, [](blink::Visitor* visitor, const void* object) {
+               reinterpret_cast<const ListHashSetNode<ValueArg, AllocatorArg>*>(
+                   object)
+                   ->Trace(visitor);
+             }}))
+      return;
+
     // The conservative stack scan can find nodes that have been removed
     // from the set and destructed. We don't need to trace these, and it
     // would be wrong to do so, because the class will not expect the trace
@@ -1202,6 +1210,14 @@ template <typename T, size_t inlineCapacity, typename U, typename V>
 template <typename VisitorDispatcher, typename A>
 std::enable_if_t<A::kIsGarbageCollected>
 ListHashSet<T, inlineCapacity, U, V>::Trace(VisitorDispatcher visitor) const {
+  if (visitor->ConcurrentTracingBailOut(
+          {this, [](blink::Visitor* visitor, const void* object) {
+             reinterpret_cast<const ListHashSet<T, inlineCapacity, U, V>*>(
+                 object)
+                 ->Trace(visitor);
+           }}))
+    return;
+
   static_assert(!IsWeak<T>::value,
                 "HeapListHashSet does not support weakness, consider using "
                 "HeapLinkedHashSet instead.");