1 /* 2 * Copyright (C) 2010 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #ifndef WrapperTypeInfo_h 32 #define WrapperTypeInfo_h 33 34 #include "gin/public/wrapper_info.h" 35 #include "platform/heap/Handle.h" 36 #include "wtf/Assertions.h" 37 #include <v8.h> 38 39 namespace WebCore { 40 41 class ActiveDOMObject; 42 class EventTarget; 43 class Node; 44 45 static const int v8DOMWrapperTypeIndex = static_cast<int>(gin::kWrapperInfoIndex); 46 static const int v8DOMWrapperObjectIndex = static_cast<int>(gin::kEncodedValueIndex); 47 static const int v8DefaultWrapperInternalFieldCount = static_cast<int>(gin::kNumberOfInternalFields); 48 static const int v8PrototypeTypeIndex = 0; 49 static const int v8PrototypeInternalFieldcount = 1; 50 51 static const uint16_t v8DOMNodeClassId = 1; 52 static const uint16_t v8DOMObjectClassId = 2; 53 54 typedef v8::Handle<v8::FunctionTemplate> (*DomTemplateFunction)(v8::Isolate*); 55 typedef void (*DerefObjectFunction)(void*); 56 typedef ActiveDOMObject* (*ToActiveDOMObjectFunction)(v8::Handle<v8::Object>); 57 typedef EventTarget* (*ToEventTargetFunction)(v8::Handle<v8::Object>); 58 typedef void (*ResolveWrapperReachabilityFunction)(void*, const v8::Persistent<v8::Object>&, v8::Isolate*); 59 typedef void (*InstallPerContextEnabledPrototypePropertiesFunction)(v8::Handle<v8::Object>, v8::Isolate*); 60 61 enum WrapperTypePrototype { 62 WrapperTypeObjectPrototype, 63 WrapperTypeExceptionPrototype 64 }; 65 66 enum GCType { 67 GarbageCollectedObject, 68 WillBeGarbageCollectedObject, 69 RefCountedObject, 70 }; 71 setObjectGroup(void * object,const v8::Persistent<v8::Object> & wrapper,v8::Isolate * isolate)72 inline void setObjectGroup(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate) 73 { 74 isolate->SetObjectGroupId(wrapper, v8::UniqueId(reinterpret_cast<intptr_t>(object))); 75 } 76 77 // This struct provides a way to store a bunch of information that is helpful when unwrapping 78 // v8 objects. Each v8 bindings class has exactly one static WrapperTypeInfo member, so 79 // comparing pointers is a safe way to determine if types match. 80 struct WrapperTypeInfo { 81 unwrapWrapperTypeInfo82 static const WrapperTypeInfo* unwrap(v8::Handle<v8::Value> typeInfoWrapper) 83 { 84 return reinterpret_cast<const WrapperTypeInfo*>(v8::External::Cast(*typeInfoWrapper)->Value()); 85 } 86 87 equalsWrapperTypeInfo88 bool equals(const WrapperTypeInfo* that) const 89 { 90 return this == that; 91 } 92 isSubclassWrapperTypeInfo93 bool isSubclass(const WrapperTypeInfo* that) const 94 { 95 for (const WrapperTypeInfo* current = this; current; current = current->parentClass) { 96 if (current == that) 97 return true; 98 } 99 100 return false; 101 } 102 domTemplateWrapperTypeInfo103 v8::Handle<v8::FunctionTemplate> domTemplate(v8::Isolate* isolate) const 104 { 105 return domTemplateFunction(isolate); 106 } 107 installPerContextEnabledMethodsWrapperTypeInfo108 void installPerContextEnabledMethods(v8::Handle<v8::Object> prototypeTemplate, v8::Isolate* isolate) const 109 { 110 if (installPerContextEnabledMethodsFunction) 111 installPerContextEnabledMethodsFunction(prototypeTemplate, isolate); 112 } 113 toActiveDOMObjectWrapperTypeInfo114 ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object> object) const 115 { 116 if (!toActiveDOMObjectFunction) 117 return 0; 118 return toActiveDOMObjectFunction(object); 119 } 120 toEventTargetWrapperTypeInfo121 EventTarget* toEventTarget(v8::Handle<v8::Object> object) const 122 { 123 if (!toEventTargetFunction) 124 return 0; 125 return toEventTargetFunction(object); 126 } 127 visitDOMWrapperWrapperTypeInfo128 void visitDOMWrapper(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate) const 129 { 130 if (!visitDOMWrapperFunction) 131 setObjectGroup(object, wrapper, isolate); 132 else 133 visitDOMWrapperFunction(object, wrapper, isolate); 134 } 135 136 // This field must be the first member of the struct WrapperTypeInfo. This is also checked by a COMPILE_ASSERT() below. 137 const gin::GinEmbedder ginEmbedder; 138 139 const DomTemplateFunction domTemplateFunction; 140 const DerefObjectFunction derefObjectFunction; 141 const ToActiveDOMObjectFunction toActiveDOMObjectFunction; 142 const ToEventTargetFunction toEventTargetFunction; 143 const ResolveWrapperReachabilityFunction visitDOMWrapperFunction; 144 const InstallPerContextEnabledPrototypePropertiesFunction installPerContextEnabledMethodsFunction; 145 const WrapperTypeInfo* parentClass; 146 const WrapperTypePrototype wrapperTypePrototype; 147 const GCType gcType; 148 }; 149 150 151 COMPILE_ASSERT(offsetof(struct WrapperTypeInfo, ginEmbedder) == offsetof(struct gin::WrapperInfo, embedder), wrapper_type_info_compatible_to_gin); 152 153 template<typename T, int offset> getInternalField(const v8::Persistent<v8::Object> & persistent)154 inline T* getInternalField(const v8::Persistent<v8::Object>& persistent) 155 { 156 // This would be unsafe, but InternalFieldCount and GetAlignedPointerFromInternalField are guaranteed not to allocate 157 const v8::Handle<v8::Object>& object = reinterpret_cast<const v8::Handle<v8::Object>&>(persistent); 158 ASSERT(offset < object->InternalFieldCount()); 159 return static_cast<T*>(object->GetAlignedPointerFromInternalField(offset)); 160 } 161 162 template<typename T, int offset> getInternalField(v8::Handle<v8::Object> wrapper)163 inline T* getInternalField(v8::Handle<v8::Object> wrapper) 164 { 165 ASSERT(offset < wrapper->InternalFieldCount()); 166 return static_cast<T*>(wrapper->GetAlignedPointerFromInternalField(offset)); 167 } 168 toNative(const v8::Persistent<v8::Object> & wrapper)169 inline void* toNative(const v8::Persistent<v8::Object>& wrapper) 170 { 171 return getInternalField<void, v8DOMWrapperObjectIndex>(wrapper); 172 } 173 toNative(v8::Handle<v8::Object> wrapper)174 inline void* toNative(v8::Handle<v8::Object> wrapper) 175 { 176 return getInternalField<void, v8DOMWrapperObjectIndex>(wrapper); 177 } 178 toWrapperTypeInfo(const v8::Persistent<v8::Object> & wrapper)179 inline const WrapperTypeInfo* toWrapperTypeInfo(const v8::Persistent<v8::Object>& wrapper) 180 { 181 return getInternalField<WrapperTypeInfo, v8DOMWrapperTypeIndex>(wrapper); 182 } 183 toWrapperTypeInfo(v8::Handle<v8::Object> wrapper)184 inline const WrapperTypeInfo* toWrapperTypeInfo(v8::Handle<v8::Object> wrapper) 185 { 186 return getInternalField<WrapperTypeInfo, v8DOMWrapperTypeIndex>(wrapper); 187 } 188 toPersistentHandle(const v8::Handle<v8::Object> & wrapper)189 inline const PersistentNode* toPersistentHandle(const v8::Handle<v8::Object>& wrapper) 190 { 191 // Persistent handle is stored in the last internal field. 192 return static_cast<PersistentNode*>(wrapper->GetAlignedPointerFromInternalField(wrapper->InternalFieldCount() - 1)); 193 } 194 releaseObject(v8::Handle<v8::Object> wrapper)195 inline void releaseObject(v8::Handle<v8::Object> wrapper) 196 { 197 const WrapperTypeInfo* typeInfo = toWrapperTypeInfo(wrapper); 198 if (typeInfo->gcType == GarbageCollectedObject) { 199 const PersistentNode* handle = toPersistentHandle(wrapper); 200 // This will be null iff a wrapper for a hidden wrapper object, 201 // see V8DOMWrapper::setNativeInfoForHiddenWrapper(). 202 delete handle; 203 } else if (typeInfo->gcType == WillBeGarbageCollectedObject) { 204 #if ENABLE(OILPAN) 205 const PersistentNode* handle = toPersistentHandle(wrapper); 206 // This will be null iff a wrapper for a hidden wrapper object, 207 // see V8DOMWrapper::setNativeInfoForHiddenWrapper(). 208 delete handle; 209 #else 210 ASSERT(typeInfo->derefObjectFunction); 211 typeInfo->derefObjectFunction(toNative(wrapper)); 212 #endif 213 } else { 214 ASSERT(typeInfo->derefObjectFunction); 215 typeInfo->derefObjectFunction(toNative(wrapper)); 216 } 217 } 218 219 struct WrapperConfiguration { 220 221 enum Lifetime { 222 Dependent, Independent 223 }; 224 configureWrapperWrapperConfiguration225 void configureWrapper(v8::PersistentBase<v8::Object>* wrapper) const 226 { 227 wrapper->SetWrapperClassId(classId); 228 if (lifetime == Independent) 229 wrapper->MarkIndependent(); 230 } 231 232 const uint16_t classId; 233 const Lifetime lifetime; 234 }; 235 buildWrapperConfiguration(void *,WrapperConfiguration::Lifetime lifetime)236 inline WrapperConfiguration buildWrapperConfiguration(void*, WrapperConfiguration::Lifetime lifetime) 237 { 238 WrapperConfiguration configuration = {v8DOMObjectClassId, lifetime}; 239 return configuration; 240 } 241 buildWrapperConfiguration(Node *,WrapperConfiguration::Lifetime lifetime)242 inline WrapperConfiguration buildWrapperConfiguration(Node*, WrapperConfiguration::Lifetime lifetime) 243 { 244 WrapperConfiguration configuration = {v8DOMNodeClassId, lifetime}; 245 return configuration; 246 } 247 } 248 249 #endif // WrapperTypeInfo_h 250