Oilpan: Clear unused slots in Deque so they are not found in conservative GCs

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 25 matching lines @@
 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 static const size_t kInitialVectorSize = 1;
 #else
 #ifndef WTF_VECTOR_INITIAL_SIZE
 #define WTF_VECTOR_INITIAL_SIZE 4
 #endif
 static const size_t kInitialVectorSize = WTF_VECTOR_INITIAL_SIZE;
 #endif
 
+    template<typename T, size_t inlineBuffer, typename Allocator>
+    class Deque;
+
     template <bool needsDestruction, typename T>
     struct VectorDestructor;
 
     template<typename T>
     struct VectorDestructor<false, T>
     {
         static void destruct(T*, T*) {}
     };
 
     template<typename T>
@@ skipping 431 matching lines @@
 
     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 { return reinterpret_cast_ptr<const T*>(m_inlineBuffer.buffer); }
 
         AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;
+        template<typename U, size_t inlineBuffer, typename V>
+        friend class Deque;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     class Vector;
 
     // VectorDestructorBase defines the destructor of a vector. This base is used in order to
     // completely avoid creating a destructor for a vector that does not need to be destructed.
     // By doing so, the clang compiler will have correct information about whether or not a
     // vector has a trivial destructor and we use that in a compiler plugin to ensure the
     // correctness of non-finalized garbage-collected classes and the use of VectorTraits::needsDestruction.
@@ skipping 682 matching lines @@
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h