HashTable check

third_party/WebKit/Source/platform/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 342 matching lines @@
 //
 // Not meant for general consumption.
 
 template <typename T, bool hasInlineCapacity, typename Allocator>
 class VectorBufferBase {
   WTF_MAKE_NONCOPYABLE(VectorBufferBase);
   DISALLOW_NEW();
 
  public:
   void allocateBuffer(size_t newCapacity) {
+    checkCreationThread();
     DCHECK(newCapacity);
     DCHECK_LE(newCapacity,
               Allocator::template maxElementCountInBackingStore<T>());
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (hasInlineCapacity)
       m_buffer =
           Allocator::template allocateInlineVectorBacking<T>(sizeToAllocate);
     else
       m_buffer = Allocator::template allocateVectorBacking<T>(sizeToAllocate);
     m_capacity = sizeToAllocate / sizeof(T);
@@ skipping 45 matching lines @@
     OffsetRange() : begin(0), end(0) {}
     explicit OffsetRange(size_t begin, size_t end) : begin(begin), end(end) {
       DCHECK_LE(begin, end);
     }
     bool empty() const { return begin == end; }
     size_t begin;
     size_t end;
   };
 
  protected:
-  VectorBufferBase() : m_buffer(nullptr), m_capacity(0) {}
+  VectorBufferBase() : m_buffer(nullptr), m_capacity(0) {
+    if (Allocator::isGarbageCollected)
+      m_creationThread = currentThread();
+  }
 
   VectorBufferBase(T* buffer, size_t capacity)
-      : m_buffer(buffer), m_capacity(capacity) {}
+      : m_buffer(buffer), m_capacity(capacity) {
+    if (Allocator::isGarbageCollected)
+      m_creationThread = currentThread();
+  }
+
+#if DCHECK_IS_ON()
+  void checkCreationThread() const {
+    DCHECK(!Allocator::isGarbageCollected ||
+           m_creationThread == currentThread());
+  }
+#endif
 
   T* m_buffer;
   unsigned m_capacity;
   unsigned m_size;
+#if DCHECK_IS_ON()
+  ThreadIdentifier m_creationThread;
+#endif
 };
 
 template <typename T,
           size_t inlineCapacity,
           typename Allocator = PartitionAllocator>
 class VectorBuffer;
 
 template <typename T, typename Allocator>
 class VectorBuffer<T, 0, Allocator>
     : protected VectorBufferBase<T, false, Allocator> {
@@ skipping 1455 matching lines @@
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h