ade1b8f8c92c8acb34e96c885fb7abb0892f8d33
[WebKit-https.git] / Source / WebCore / bindings / v8 / WrapperTypeInfo.h
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 <v8.h>
35
36 namespace WebCore {
37     
38     class ActiveDOMObject;
39     class DOMDataStore;
40
41     static const int v8DOMWrapperTypeIndex = 0;
42     static const int v8DOMWrapperObjectIndex = 1;
43     static const int v8DefaultWrapperInternalFieldCount = 2;
44
45     static const uint16_t v8DOMNodeClassId = 1;
46     static const uint16_t v8DOMObjectClassId = 2;
47
48     typedef v8::Persistent<v8::FunctionTemplate> (*GetTemplateFunction)(v8::Isolate*);
49     typedef void (*DerefObjectFunction)(void*);
50     typedef ActiveDOMObject* (*ToActiveDOMObjectFunction)(v8::Handle<v8::Object>);
51     typedef void* (*OpaqueRootForGC)(void*, v8::Persistent<v8::Object>);
52     typedef void (*InstallPerContextPrototypePropertiesFunction)(v8::Handle<v8::Object>);
53
54     enum WrapperTypePrototype {
55         WrapperTypeObjectPrototype,
56         WrapperTypeErrorPrototype
57     };
58
59     // This struct provides a way to store a bunch of information that is helpful when unwrapping
60     // v8 objects. Each v8 bindings class has exactly one static WrapperTypeInfo member, so
61     // comparing pointers is a safe way to determine if types match.
62     struct WrapperTypeInfo {
63
64         static WrapperTypeInfo* unwrap(v8::Handle<v8::Value> typeInfoWrapper)
65         {
66             return reinterpret_cast<WrapperTypeInfo*>(v8::External::Cast(*typeInfoWrapper)->Value());
67         }
68         
69         
70         bool equals(const WrapperTypeInfo* that) const
71         {
72             return this == that;
73         }
74
75         bool isSubclass(const WrapperTypeInfo* that) const
76         {
77             for (const WrapperTypeInfo* current = this; current; current = current->parentClass) {
78                 if (current == that)
79                     return true;
80             }
81
82             return false;
83         }
84         
85         v8::Persistent<v8::FunctionTemplate> getTemplate(v8::Isolate* isolate = 0) { return getTemplateFunction(isolate); }
86         
87         void derefObject(void* object)
88         {
89             if (derefObjectFunction) 
90                 derefObjectFunction(object);
91         }
92         
93         void installPerContextPrototypeProperties(v8::Handle<v8::Object> proto)
94         {
95             if (installPerContextPrototypePropertiesFunction)
96                 installPerContextPrototypePropertiesFunction(proto);
97         }
98
99         ActiveDOMObject* toActiveDOMObject(v8::Handle<v8::Object> object)
100         {
101             if (!toActiveDOMObjectFunction)
102                 return 0;
103             return toActiveDOMObjectFunction(object);
104         }
105
106         void* opaqueRootForGC(void* object, v8::Persistent<v8::Object> wrapper)
107         {
108             if (!opaqueRootForGCFunction)
109                 return object;
110             return opaqueRootForGCFunction(object, wrapper);
111         }
112
113         const GetTemplateFunction getTemplateFunction;
114         const DerefObjectFunction derefObjectFunction;
115         const ToActiveDOMObjectFunction toActiveDOMObjectFunction;
116         const OpaqueRootForGC opaqueRootForGCFunction;
117         const InstallPerContextPrototypePropertiesFunction installPerContextPrototypePropertiesFunction;
118         const WrapperTypeInfo* parentClass;
119         const WrapperTypePrototype wrapperTypePrototype;
120     };
121
122     inline void* toNative(v8::Handle<v8::Object> object)
123     {
124         ASSERT(object->InternalFieldCount() >= v8DOMWrapperObjectIndex);
125         return object->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex);
126     }
127
128     inline WrapperTypeInfo* toWrapperTypeInfo(v8::Handle<v8::Object> object)
129     {
130         ASSERT(object->InternalFieldCount() >= v8DOMWrapperTypeIndex);
131         return static_cast<WrapperTypeInfo*>(object->GetAlignedPointerFromInternalField(v8DOMWrapperTypeIndex));
132     }
133
134 }
135
136 #endif // WrapperTypeInfo_h