Devirtualize Visitor and remove inline visitor specialization.

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

 /*
  * 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 18 matching lines @@
  */
 
 #include "platform/heap/HeapPage.h"
 
 #include "base/trace_event/process_memory_dump.h"
 #include "platform/MemoryCoordinator.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/heap/BlinkGCMemoryDumpProvider.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/HeapCompact.h"
-#include "platform/heap/MarkingVisitor.h"
 #include "platform/heap/PageMemory.h"
 #include "platform/heap/PagePool.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/instrumentation/tracing/web_memory_allocator_dump.h"
 #include "platform/instrumentation/tracing/web_process_memory_dump.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/AutoReset.h"
@@ skipping 1643 matching lines @@
     // has not yet been initialized. In this case, we should mark the A
     // object without tracing any member of the A object.
     visitor->markHeaderNoTracing(header);
     ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
   } else {
     visitor->markHeader(header, gcInfo->m_trace);
   }
 }
 
 void NormalPage::checkAndMarkPointer(Visitor* visitor, Address address) {
-  ASSERT(contains(address));
+#if DCHECK_IS_ON()
+  DCHECK(contains(address));
+#endif
   HeapObjectHeader* header = findHeaderFromAddress(address);
   if (!header || header->isDead())
     return;
   markPointer(visitor, header);
 }
 
+#if DCHECK_IS_ON()
+void NormalPage::checkAndMarkPointer(Visitor* visitor,
+                                     Address address,
+                                     MarkedPointerCallbackForTesting callback) {
+  DCHECK(contains(address));
+  HeapObjectHeader* header = findHeaderFromAddress(address);
+  if (!header || header->isDead())
+    return;
+  if (!callback(header))
+    markPointer(visitor, header);
+}
+#endif
+
 void NormalPage::markOrphaned() {
 // Zap the payload with a recognizable value to detect any incorrect
 // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
   // This needs to zap poisoned memory as well.
   // Force unpoison memory before memset.
   ASAN_UNPOISON_MEMORY_REGION(payload(), payloadSize());
 #endif
   OrphanedPagePool::asanDisabledMemset(
       payload(), OrphanedPagePool::orphanedZapValue, payloadSize());
@@ skipping 100 matching lines @@
 
 #if defined(ADDRESS_SANITIZER)
 void LargeObjectPage::poisonUnmarkedObjects() {
   HeapObjectHeader* header = heapObjectHeader();
   if (!header->isMarked())
     ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
 }
 #endif
 
 void LargeObjectPage::checkAndMarkPointer(Visitor* visitor, Address address) {
-  ASSERT(contains(address));
+#if DCHECK_IS_ON()
+  DCHECK(contains(address));
+#endif
   if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
     return;
   markPointer(visitor, heapObjectHeader());
 }
 
+#if DCHECK_IS_ON()
+void LargeObjectPage::checkAndMarkPointer(
+    Visitor* visitor,
+    Address address,
+    MarkedPointerCallbackForTesting callback) {
+  DCHECK(contains(address));
+  if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
+    return;
+  if (!callback(heapObjectHeader()))
+    markPointer(visitor, heapObjectHeader());
+}
+#endif
+
 void LargeObjectPage::markOrphaned() {
   // Zap the payload with a recognizable value to detect any incorrect
   // cross thread pointer usage.
   OrphanedPagePool::asanDisabledMemset(
       payload(), OrphanedPagePool::orphanedZapValue, payloadSize());
   BasePage::markOrphaned();
 }
 
 void LargeObjectPage::takeSnapshot(
     base::trace_event::MemoryAllocatorDump* pageDump,
@@ skipping 65 matching lines @@
 
   m_hasEntries = true;
   size_t index = hash(address);
   ASSERT(!(index & 1));
   Address cachePage = roundToBlinkPageStart(address);
   m_entries[index + 1] = m_entries[index];
   m_entries[index] = cachePage;
 }
 
 }  // namespace blink