Oilpan: Assert that updator functions of HashMap, HashSet, and Vector should not be used during wea…

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 994 matching lines @@
         Base::deallocateBuffer(oldBuffer);
     }
 
     // Templatizing these is better than just letting the conversion happen implicitly,
     // because for instance it allows a PassRefPtr to be appended to a RefPtr vector
     // without refcount thrash.
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::append(const U* data, size_t dataSize)
     {
+        ASSERT(Allocator::isAllocationAllowed());
         size_t newSize = m_size + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
         RELEASE_ASSERT(newSize >= m_size);
         T* dest = end();
         VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(data, &data[dataSize], dest);
         m_size = newSize;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::append(const U& val)
     {
+        ASSERT(Allocator::isAllocationAllowed());
         if (LIKELY(size() != capacity())) {
             new (NotNull, end()) T(val);
             ++m_size;
             return;
         }
 
         appendSlowCase(val);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
@@ skipping 23 matching lines @@
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U, size_t otherCapacity, typename OtherAllocator>
     inline void Vector<T, inlineCapacity, Allocator>::appendVector(const Vector<U, otherCapacity, OtherAllocator>& val)
     {
         append(val.begin(), val.size());
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const U* data, size_t dataSize)
     {
+        ASSERT(Allocator::isAllocationAllowed());
         RELEASE_ASSERT(position <= size());
         size_t newSize = m_size + dataSize;
         if (newSize > capacity()) {
             data = expandCapacity(newSize, data);
             ASSERT(begin());
         }
         RELEASE_ASSERT(newSize >= m_size);
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + dataSize);
         VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(data, &data[dataSize], spot);
         m_size = newSize;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator> template<typename U>
     inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position, const U& val)
     {
+        ASSERT(Allocator::isAllocationAllowed());
         RELEASE_ASSERT(position <= size());
         const U* data = &val;
         if (size() == capacity()) {
             data = expandCapacity(size() + 1, data);
             ASSERT(begin());
         }
         T* spot = begin() + position;
         TypeOperations::moveOverlapping(spot, end(), spot + 1);
         new (NotNull, spot) T(*data);
         ++m_size;
@@ skipping 105 matching lines @@
     struct NeedsTracing<Vector<T, N> > {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h