Remove NO_LAZY_SWEEP_SANITIZE_ADDRESS

third_party/WebKit/Source/platform/heap/Persistent.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 Persistent_h
 #define Persistent_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Member.h"
 #include "platform/heap/PersistentNode.h"
@@ skipping 154 matching lines @@
   }
 
  protected:
   NO_SANITIZE_ADDRESS
   T* atomicGet() {
     return reinterpret_cast<T*>(
         acquireLoad(reinterpret_cast<void* volatile*>(&m_raw)));
   }
 
  private:
-  NO_LAZY_SWEEP_SANITIZE_ADDRESS
+  NO_SANITIZE_ADDRESS
   void assign(T* ptr) {
     if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration)
       releaseStore(reinterpret_cast<void* volatile*>(&m_raw), ptr);
     else
       m_raw = ptr;
     checkPointer();
     if (m_raw) {
       if (!m_persistentNode)
         initialize();
       return;
@@ skipping 10 matching lines @@
       if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration)
         visitor->registerWeakCellWithCallback(reinterpret_cast<void**>(this),
                                               handleWeakPersistent);
       else
         visitor->registerWeakMembers(this, m_raw, handleWeakPersistent);
     } else {
       visitor->mark(m_raw);
     }
   }
 
-  NO_LAZY_SWEEP_SANITIZE_ADDRESS
+  NO_SANITIZE_ADDRESS
   void initialize() {
     ASSERT(!m_persistentNode);
     if (!m_raw || isHashTableDeletedValue())
       return;
 
     TraceCallback traceCallback =
         TraceMethodDelegate<PersistentBase,
                             &PersistentBase::tracePersistent>::trampoline;
     if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
       ProcessHeap::crossThreadPersistentRegion().allocatePersistentNode(
@@ skipping 365 matching lines @@
 
   // Used when the registered PersistentNode of this object is
   // released during ThreadState shutdown, clearing the association.
   static void clearPersistentNode(void* self) {
     PersistentHeapCollectionBase<Collection>* collection =
         (reinterpret_cast<PersistentHeapCollectionBase<Collection>*>(self));
     collection->uninitialize();
     collection->clear();
   }
 
-  NO_LAZY_SWEEP_SANITIZE_ADDRESS
+  NO_SANITIZE_ADDRESS
   void initialize() {
     // FIXME: Derive affinity based on the collection.
     ThreadState* state = ThreadState::current();
     ASSERT(state->checkThread());
     m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(
         this,
         TraceMethodDelegate<PersistentHeapCollectionBase<Collection>,
                             &PersistentHeapCollectionBase<
                                 Collection>::tracePersistent>::trampoline);
 #if ENABLE(ASSERT)
@@ skipping 199 matching lines @@
   static blink::CrossThreadPersistent<T> Unwrap(
       const blink::CrossThreadWeakPersistent<T>& wrapped) {
     blink::CrossThreadPersistentRegion::LockScope persistentLock(
         blink::ProcessHeap::crossThreadPersistentRegion());
     return blink::CrossThreadPersistent<T>(wrapped.get());
   }
 };
 }
 
 #endif  // Persistent_h