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