Upstream version 10.39.225.0
[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / bindings / tests / results / core / V8TestInterfaceConstructor3.h
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 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
6
7 #ifndef V8TestInterfaceConstructor3_h
8 #define V8TestInterfaceConstructor3_h
9
10 #include "bindings/core/v8/ScriptWrappable.h"
11 #include "bindings/core/v8/V8Binding.h"
12 #include "bindings/core/v8/V8DOMWrapper.h"
13 #include "bindings/core/v8/WrapperTypeInfo.h"
14 #include "bindings/tests/idls/core/TestInterfaceConstructor3.h"
15 #include "platform/heap/Handle.h"
16
17 namespace blink {
18
19 class V8TestInterfaceConstructor3 {
20 public:
21     static bool hasInstance(v8::Handle<v8::Value>, v8::Isolate*);
22     static v8::Handle<v8::Object> findInstanceInPrototypeChain(v8::Handle<v8::Value>, v8::Isolate*);
23     static v8::Handle<v8::FunctionTemplate> domTemplate(v8::Isolate*);
24     static TestInterfaceConstructor3* toImpl(v8::Handle<v8::Object> object)
25     {
26         return toImpl(blink::toScriptWrappableBase(object));
27     }
28     static TestInterfaceConstructor3* toImplWithTypeCheck(v8::Isolate*, v8::Handle<v8::Value>);
29     static const WrapperTypeInfo wrapperTypeInfo;
30     static void refObject(ScriptWrappableBase* internalPointer);
31     static void derefObject(ScriptWrappableBase* internalPointer);
32     static WrapperPersistentNode* createPersistentHandle(ScriptWrappableBase* internalPointer);
33     static void constructorCallback(const v8::FunctionCallbackInfo<v8::Value>&);
34     static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + 0;
35     static inline ScriptWrappableBase* toScriptWrappableBase(TestInterfaceConstructor3* impl)
36     {
37         return impl->toScriptWrappableBase();
38     }
39
40     static inline TestInterfaceConstructor3* toImpl(ScriptWrappableBase* internalPointer)
41     {
42         return internalPointer->toImpl<TestInterfaceConstructor3>();
43     }
44     static void installConditionallyEnabledProperties(v8::Handle<v8::Object>, v8::Isolate*) { }
45     static void installConditionallyEnabledMethods(v8::Handle<v8::Object>, v8::Isolate*) { }
46
47 private:
48 };
49
50 inline v8::Handle<v8::Object> wrap(TestInterfaceConstructor3* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
51 {
52     return impl->wrap(creationContext, isolate);
53 }
54
55 inline v8::Handle<v8::Value> toV8(TestInterfaceConstructor3* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
56 {
57     if (UNLIKELY(!impl))
58         return v8::Null(isolate);
59     v8::Handle<v8::Value> wrapper = DOMDataStore::getWrapper<V8TestInterfaceConstructor3>(impl, isolate);
60     if (!wrapper.IsEmpty())
61         return wrapper;
62
63     return impl->wrap(creationContext, isolate);
64 }
65
66 template<typename CallbackInfo>
67 inline void v8SetReturnValue(const CallbackInfo& callbackInfo, TestInterfaceConstructor3* impl)
68 {
69     if (UNLIKELY(!impl)) {
70         v8SetReturnValueNull(callbackInfo);
71         return;
72     }
73     if (DOMDataStore::setReturnValueFromWrapper<V8TestInterfaceConstructor3>(callbackInfo.GetReturnValue(), impl))
74         return;
75     v8::Handle<v8::Object> wrapper = wrap(impl, callbackInfo.Holder(), callbackInfo.GetIsolate());
76     v8SetReturnValue(callbackInfo, wrapper);
77 }
78
79 template<typename CallbackInfo>
80 inline void v8SetReturnValueForMainWorld(const CallbackInfo& callbackInfo, TestInterfaceConstructor3* impl)
81 {
82     ASSERT(DOMWrapperWorld::current(callbackInfo.GetIsolate()).isMainWorld());
83     if (UNLIKELY(!impl)) {
84         v8SetReturnValueNull(callbackInfo);
85         return;
86     }
87     if (DOMDataStore::setReturnValueFromWrapperForMainWorld<V8TestInterfaceConstructor3>(callbackInfo.GetReturnValue(), impl))
88         return;
89     v8::Handle<v8::Value> wrapper = wrap(impl, callbackInfo.Holder(), callbackInfo.GetIsolate());
90     v8SetReturnValue(callbackInfo, wrapper);
91 }
92
93 template<class CallbackInfo, class Wrappable>
94 inline void v8SetReturnValueFast(const CallbackInfo& callbackInfo, TestInterfaceConstructor3* impl, Wrappable* wrappable)
95 {
96     if (UNLIKELY(!impl)) {
97         v8SetReturnValueNull(callbackInfo);
98         return;
99     }
100     if (DOMDataStore::setReturnValueFromWrapperFast<V8TestInterfaceConstructor3>(callbackInfo.GetReturnValue(), impl, callbackInfo.Holder(), wrappable))
101         return;
102     v8::Handle<v8::Object> wrapper = wrap(impl, callbackInfo.Holder(), callbackInfo.GetIsolate());
103     v8SetReturnValue(callbackInfo, wrapper);
104 }
105
106 inline v8::Handle<v8::Value> toV8(PassRefPtr<TestInterfaceConstructor3> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
107 {
108     return toV8(impl.get(), creationContext, isolate);
109 }
110
111 template<class CallbackInfo>
112 inline void v8SetReturnValue(const CallbackInfo& callbackInfo, PassRefPtr<TestInterfaceConstructor3> impl)
113 {
114     v8SetReturnValue(callbackInfo, impl.get());
115 }
116
117 template<class CallbackInfo>
118 inline void v8SetReturnValueForMainWorld(const CallbackInfo& callbackInfo, PassRefPtr<TestInterfaceConstructor3> impl)
119 {
120     v8SetReturnValueForMainWorld(callbackInfo, impl.get());
121 }
122
123 template<class CallbackInfo, class Wrappable>
124 inline void v8SetReturnValueFast(const CallbackInfo& callbackInfo, PassRefPtr<TestInterfaceConstructor3> impl, Wrappable* wrappable)
125 {
126     v8SetReturnValueFast(callbackInfo, impl.get(), wrappable);
127 }
128
129 } // namespace blink
130 #endif // V8TestInterfaceConstructor3_h