Unpoison CrossThreadPersistents

third_party/WebKit/Source/platform/heap/PersistentNode.cpp

 // Copyright 2015 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 "platform/heap/PersistentNode.h"
 
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
@@ skipping 99 matching lines @@
       if (freeListLast) {
         ASSERT(freeListNext);
         ASSERT(!freeListLast->freeListNext());
         freeListLast->setFreeListNext(m_freeListHead);
         m_freeListHead = freeListNext;
       }
       prevNext = &slots->m_next;
       slots = slots->m_next;
     }
   }
-  ASSERT(persistentCount == m_persistentCount);
+  DCHECK_EQ(persistentCount, m_persistentCount);
 }
 
 bool CrossThreadPersistentRegion::shouldTracePersistentNode(
     Visitor* visitor,
     PersistentNode* node) {
   CrossThreadPersistent<DummyGCBase>* persistent =
       reinterpret_cast<CrossThreadPersistent<DummyGCBase>*>(node->self());
   DCHECK(persistent);
   DCHECK(!persistent->isHashTableDeletedValue());
   Address rawObject = reinterpret_cast<Address>(persistent->get());
@@ skipping 35 matching lines @@
         continue;
       if (page->arena()->getThreadState() == threadState) {
         persistent->clear();
         ASSERT(slots->m_slot[i].isUnused());
       }
     }
     slots = slots->m_next;
   }
 }
 
+#if defined(ADDRESS_SANITIZER)
+void CrossThreadPersistentRegion::unpoisonCrossThreadPersistents() {
+  MutexLocker lock(m_mutex);
+  int persistentCount = 0;
+  for (PersistentNodeSlots* slots = m_persistentRegion->m_slots; slots;
+       slots = slots->m_next) {
+    for (int i = 0; i < PersistentNodeSlots::slotCount; ++i) {

[haraken, 2016/10/17 07:32:40]

Maybe can you simply unpoison m_slot[0 : slotCount] in one call, regardless of
whether the slots are unused or not?

[keishi, 2016/10/17 07:43:00]

We are unpoisoning the persistents, not the persistent nodes, so we cannot do it
in one call. We need to call isUnused because if it is true, m_self points to a
PersistentNode instead of a persistent.

[haraken, 2016/10/17 07:49:04]

Ah, thanks, makes sense.

+      const PersistentNode& node = slots->m_slot[i];
+      if (!node.isUnused()) {
+        ASAN_UNPOISON_MEMORY_REGION(node.self(),
+                                    sizeof(CrossThreadPersistent<void*>));
+        ++persistentCount;
+      }
+    }
+  }
+  DCHECK_EQ(persistentCount, m_persistentRegion->m_persistentCount);
+}
+#endif
+
 }  // namespace blink