1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef HEAP_STUBS_H_ 6 #define HEAP_STUBS_H_ 7 8 #include "stddef.h" 9 10 #define WTF_MAKE_FAST_ALLOCATED \ 11 public: \ 12 void* operator new(size_t, void* p); \ 13 void* operator new[](size_t, void* p); \ 14 void* operator new(size_t size); \ 15 private: \ 16 typedef int __thisIsHereToForceASemicolonAfterThisMacro 17 18 namespace WTF { 19 20 template<typename T> class RefCounted { }; 21 22 template<typename T> class RawPtr { 23 public: 24 operator T*() const { return 0; } 25 T* operator->() { return 0; } 26 }; 27 28 template<typename T> class RefPtr { 29 public: 30 ~RefPtr() { } 31 operator T*() const { return 0; } 32 T* operator->() { return 0; } 33 }; 34 35 template<typename T> class OwnPtr { 36 public: 37 ~OwnPtr() { } 38 operator T*() const { return 0; } 39 T* operator->() { return 0; } 40 }; 41 42 class DefaultAllocator { 43 public: 44 static const bool isGarbageCollected = false; 45 }; 46 47 template<typename T> 48 struct VectorTraits { 49 static const bool needsDestruction = true; 50 }; 51 52 template<size_t inlineCapacity, bool isGarbageCollected, bool tNeedsDestruction> 53 class VectorDestructorBase { 54 public: 55 ~VectorDestructorBase() {} 56 }; 57 58 template<size_t inlineCapacity> 59 class VectorDestructorBase<inlineCapacity, true, false> {}; 60 61 template<> 62 class VectorDestructorBase<0, true, true> {}; 63 64 template< 65 typename T, 66 size_t inlineCapacity = 0, 67 typename Allocator = DefaultAllocator> 68 class Vector : public VectorDestructorBase<inlineCapacity, 69 Allocator::isGarbageCollected, 70 VectorTraits<T>::needsDestruction> { 71 public: 72 size_t size(); 73 T& operator[](size_t); 74 }; 75 76 template< 77 typename T, 78 size_t inlineCapacity = 0, 79 typename Allocator = DefaultAllocator> 80 class Deque {}; 81 82 template< 83 typename ValueArg, 84 typename HashArg = void, 85 typename TraitsArg = void, 86 typename Allocator = DefaultAllocator> 87 class HashSet {}; 88 89 template< 90 typename ValueArg, 91 typename HashArg = void, 92 typename TraitsArg = void, 93 typename Allocator = DefaultAllocator> 94 class ListHashSet {}; 95 96 template< 97 typename ValueArg, 98 typename HashArg = void, 99 typename TraitsArg = void, 100 typename Allocator = DefaultAllocator> 101 class LinkedHashSet {}; 102 103 template< 104 typename ValueArg, 105 typename HashArg = void, 106 typename TraitsArg = void, 107 typename Allocator = DefaultAllocator> 108 class HashCountedSet {}; 109 110 template< 111 typename KeyArg, 112 typename MappedArg, 113 typename HashArg = void, 114 typename KeyTraitsArg = void, 115 typename MappedTraitsArg = void, 116 typename Allocator = DefaultAllocator> 117 class HashMap {}; 118 119 } 120 121 namespace WebCore { 122 123 using namespace WTF; 124 125 #define DISALLOW_ALLOCATION() \ 126 private: \ 127 void* operator new(size_t) = delete; \ 128 void* operator new(size_t, void*) = delete; 129 130 #define STACK_ALLOCATED() \ 131 private: \ 132 __attribute__((annotate("blink_stack_allocated"))) \ 133 void* operator new(size_t) = delete; \ 134 void* operator new(size_t, void*) = delete; 135 136 #define ALLOW_ONLY_INLINE_ALLOCATION() \ 137 public: \ 138 void* operator new(size_t, void*); \ 139 private: \ 140 void* operator new(size_t) = delete; 141 142 #define GC_PLUGIN_IGNORE(bug) \ 143 __attribute__((annotate("blink_gc_plugin_ignore"))) 144 145 #define USING_GARBAGE_COLLECTED_MIXIN(type) \ 146 public: \ 147 virtual void adjustAndMark(Visitor*) const {} \ 148 virtual bool isAlive(Visitor*) const { return 0; } 149 150 template<typename T> class GarbageCollected { }; 151 152 template<typename T> 153 class GarbageCollectedFinalized : public GarbageCollected<T> { }; 154 155 template<typename T> class Member { 156 public: 157 operator T*() const { return 0; } 158 T* operator->() { return 0; } 159 bool operator!() const { return false; } 160 }; 161 162 template<typename T> class WeakMember { 163 public: 164 operator T*() const { return 0; } 165 T* operator->() { return 0; } 166 bool operator!() const { return false; } 167 }; 168 169 template<typename T> class Persistent { 170 public: 171 operator T*() const { return 0; } 172 T* operator->() { return 0; } 173 bool operator!() const { return false; } 174 }; 175 176 class HeapAllocator { 177 public: 178 static const bool isGarbageCollected = true; 179 }; 180 181 template<typename T, size_t inlineCapacity = 0> 182 class HeapVector : public Vector<T, inlineCapacity, HeapAllocator> { }; 183 184 template<typename T, size_t inlineCapacity = 0> 185 class HeapDeque : public Vector<T, inlineCapacity, HeapAllocator> { }; 186 187 template<typename T> 188 class HeapHashSet : public HashSet<T, void, void, HeapAllocator> { }; 189 190 template<typename T> 191 class HeapListHashSet : public ListHashSet<T, void, void, HeapAllocator> { }; 192 193 template<typename T> 194 class HeapLinkedHashSet : public LinkedHashSet<T, void, void, HeapAllocator> { 195 }; 196 197 template<typename T> 198 class HeapHashCountedSet : public HashCountedSet<T, void, void, HeapAllocator> { 199 }; 200 201 template<typename K, typename V> 202 class HeapHashMap : public HashMap<K, V, void, void, void, HeapAllocator> { }; 203 204 template<typename T> 205 class PersistentHeapVector : public Vector<T, 0, HeapAllocator> { }; 206 207 class Visitor { 208 public: 209 template<typename T> 210 void trace(const T&); 211 212 template<typename T, void (T::*method)(Visitor*)> 213 void registerWeakMembers(const T* obj); 214 }; 215 216 class GarbageCollectedMixin { 217 virtual void adjustAndMark(Visitor*) const = 0; 218 virtual bool isAlive(Visitor*) const = 0; 219 }; 220 221 } 222 223 namespace WTF { 224 225 template<typename T> 226 struct VectorTraits<WebCore::Member<T> > { 227 static const bool needsDestruction = false; 228 }; 229 230 } 231 232 #endif 233
