Devirtualize Visitor and remove inline visitor specialization.

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

 /*
  * 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 336 matching lines @@
 }
 
 #if DCHECK_IS_ON()
 // Sanity check for a page header address: the address of the page
 // header should be OS page size away from being Blink page size
 // aligned.
 inline bool isPageHeaderAddress(Address address) {
   return !((reinterpret_cast<uintptr_t>(address) & blinkPageOffsetMask) -
            blinkGuardPageSize);
 }
+
+// Callback used for unit testing the marking of conservative pointers
+// (checkAndMarkPointer().) For each pointer that has been discovered
+// to point to a heap object, the callback is invoked with a pointer
+// to its header. If the callback returns |true|, the object will not
+// be marked.
+using MarkedPointerCallback = bool (*)(HeapObjectHeader*);

[haraken, 2017/01/25 06:14:08]

MarkedPointerCallbackForTesting ?

[sof, 2017/01/25 06:25:24]

Done.

 #endif
 
 // BasePage is a base class for NormalPage and LargeObjectPage.
 //
 // - NormalPage is a page whose size is |blinkPageSize|. NormalPage can contain
 //   multiple objects in the page. An object whose size is smaller than
 //   |largeObjectSizeThreshold| is stored in NormalPage.
 //
 // - LargeObjectPage is a page that contains only one object. The object size
 //   is arbitrary. An object whose size is larger than |blinkPageSize| is stored
@@ skipping 34 matching lines @@
 #endif
   // Check if the given address points to an object in this
   // heap page. If so, find the start of that object and mark it
   // using the given Visitor. Otherwise do nothing. The pointer must
   // be within the same aligned blinkPageSize as the this-pointer.
   //
   // This is used during conservative stack scanning to
   // conservatively mark all objects that could be referenced from
   // the stack.
   virtual void checkAndMarkPointer(Visitor*, Address) = 0;
+#if DCHECK_IS_ON()
+  virtual void checkAndMarkPointer(Visitor*,
+                                   Address,
+                                   MarkedPointerCallback) = 0;
+#endif
   virtual void markOrphaned();
 
   class HeapSnapshotInfo {
     STACK_ALLOCATED();
 
    public:
     size_t freeCount = 0;
     size_t freeSize = 0;
   };
 
@@ skipping 61 matching lines @@
   void sweep() override;
   void makeConsistentForGC() override;
   void makeConsistentForMutator() override;
   void invalidateObjectStartBitmap() override {
     m_objectStartBitMapComputed = false;
   }
 #if defined(ADDRESS_SANITIZER)
   void poisonUnmarkedObjects() override;
 #endif
   void checkAndMarkPointer(Visitor*, Address) override;
+#if DCHECK_IS_ON()
+  void checkAndMarkPointer(Visitor*, Address, MarkedPointerCallback) override;
+#endif
   void markOrphaned() override;
 
   void takeSnapshot(base::trace_event::MemoryAllocatorDump*,
                     ThreadState::GCSnapshotInfo&,
                     HeapSnapshotInfo&) override;
 #if DCHECK_IS_ON()
   // Returns true for the whole blinkPageSize page that the page is on, even
   // for the header, and the unmapped guard page at the start. That ensures
   // the result can be used to populate the negative page cache.
   bool contains(Address) override;
@@ skipping 58 matching lines @@
   bool isEmpty() override;
   void removeFromHeap() override;
   void sweep() override;
   void makeConsistentForGC() override;
   void makeConsistentForMutator() override;
   void invalidateObjectStartBitmap() override {}
 #if defined(ADDRESS_SANITIZER)
   void poisonUnmarkedObjects() override;
 #endif
   void checkAndMarkPointer(Visitor*, Address) override;
+#if DCHECK_IS_ON()
+  void checkAndMarkPointer(Visitor*, Address, MarkedPointerCallback) override;
+#endif
   void markOrphaned() override;
 
   void takeSnapshot(base::trace_event::MemoryAllocatorDump*,
                     ThreadState::GCSnapshotInfo&,
                     HeapSnapshotInfo&) override;
 #if DCHECK_IS_ON()
   // Returns true for any address that is on one of the pages that this
   // large object uses. That ensures that we can use a negative result to
   // populate the negative page cache.
   bool contains(Address) override;
@@ skipping 371 matching lines @@
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h