Introduce ThreadState::isOnThreadHeap() helper predicate.

third_party/WebKit/Source/platform/heap/Member.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 Member_h
 #define Member_h
 
 #include "wtf/Allocator.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashTraits.h"
@@ skipping 118 matching lines @@
       return;
 
     if (tracenessConfiguration != TracenessMemberConfiguration::Untraced) {
       ThreadState* current = ThreadState::current();
       DCHECK(current);
       // m_creationThreadState may be null when this is used in a heap
       // collection which initialized the Member with memset and the
       // constructor wasn't called.
       if (m_creationThreadState) {
         // Member should point to objects that belong in the same ThreadHeap.
-        DCHECK_EQ(&ThreadState::fromObject(m_raw)->heap(),
-                  &m_creationThreadState->heap());
+        DCHECK(m_creationThreadState->isOnThreadHeap(m_raw));
         // Member should point to objects that belong in the same ThreadHeap.
         DCHECK_EQ(&current->heap(), &m_creationThreadState->heap());
       } else {
-        DCHECK_EQ(&ThreadState::fromObject(m_raw)->heap(), &current->heap());
+        DCHECK(current->isOnThreadHeap(m_raw));
       }
     }
 
 #if defined(ADDRESS_SANITIZER)
     // TODO(haraken): What we really want to check here is that the pointer
     // is a traceable object. In other words, the pointer is either of:
     //
     //   (a) a pointer to the head of an on-heap object.
     //   (b) a pointer to the head of an on-heap mixin object.
     //
@@ skipping 199 matching lines @@
     if (reinterpret_cast<intptr_t>(this->m_raw) % allocationGranularity)
       return;
 
     ThreadState* current = ThreadState::current();
     DCHECK(current);
     // m_creationThreadState may be null when this is used in a heap
     // collection which initialized the Member with memset and the
     // constructor wasn't called.
     if (m_creationThreadState) {
       // Member should point to objects that belong in the same ThreadHeap.
-      CHECK_EQ(&ThreadState::fromObject(this->m_raw)->heap(),
-               &m_creationThreadState->heap());
+      CHECK(m_creationThreadState->isOnThreadHeap(this->m_raw));
       // Member should point to objects that belong in the same ThreadHeap.
       CHECK_EQ(&current->heap(), &m_creationThreadState->heap());
     } else {
-      CHECK_EQ(&ThreadState::fromObject(this->m_raw)->heap(), &current->heap());
+      CHECK(current->isOnThreadHeap(this->m_raw));
     }
   }
 
   void saveCreationThreadState() {
     m_creationThreadState = ThreadState::current();
     // All Members should be created in an attached thread, but an empty
     // value Member may be created on an unattached thread by a heap
     // collection iterator.
     CHECK(this->m_creationThreadState || !this->m_raw);
   }
@@ skipping 189 matching lines @@
 
 template <typename T>
 struct IsTraceable<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(IsTraceable);
   static const bool value = true;
 };
 
 }  // namespace WTF
 
 #endif  // Member_h