Simple BlinkGC heap compaction.

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 474 matching lines @@
 
   using Base::clearUnusedSlots;
   using Base::checkUnusedSlots;
 
   bool hasOutOfLineBuffer() const {
     // When inlineCapacity is 0 we have an out of line buffer if we have a
     // buffer.
     return buffer();
   }
 
+  T** bufferSlot() { return &m_buffer; }
+
  protected:
   using Base::m_size;
 
  private:
   using Base::m_buffer;
   using Base::m_capacity;
 };
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 class VectorBuffer : protected VectorBufferBase<T, true, Allocator> {
@@ skipping 259 matching lines @@
     Allocator::leaveGCForbiddenScope();
   }
 
   using Base::buffer;
   using Base::capacity;
 
   bool hasOutOfLineBuffer() const {
     return buffer() && buffer() != inlineBuffer();
   }
 
+  T** bufferSlot() { return &m_buffer; }
+
  protected:
   using Base::m_size;
 
  private:
   using Base::m_buffer;
   using Base::m_capacity;
 
   static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
   T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
   const T* inlineBuffer() const {
@@ skipping 804 matching lines @@
   if (!buffer())
     return;
   if (this->hasOutOfLineBuffer()) {
     // This is a performance optimization for a case where the buffer has
     // been already traced by somewhere. This can happen if the conservative
     // scanning traced an on-stack (false-positive or real) pointer to the
     // HeapVector, and then visitor->trace() traces the HeapVector.
     if (Allocator::isHeapObjectAlive(buffer()))
       return;
     Allocator::markNoTracing(visitor, buffer());
+    Allocator::registerBackingStoreReference(visitor, Base::bufferSlot());
   }
   const T* bufferBegin = buffer();
   const T* bufferEnd = buffer() + size();
   if (IsTraceableInCollectionTrait<VectorTraits<T>>::value) {
     for (const T* bufferEntry = bufferBegin; bufferEntry != bufferEnd;
          bufferEntry++)
       Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h