OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY! | 5 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY! |
6 | 6 |
7 #include "config.h" | 7 #include "config.h" |
8 #include "V8TestObject.h" | 8 #include "V8TestObject.h" |
9 | 9 |
10 #include "bindings/core/v8/BindingSecurity.h" | 10 #include "bindings/core/v8/BindingSecurity.h" |
(...skipping 711 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
722 { | 722 { |
723 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 723 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
724 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeGetter(info); | 724 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeGetter(info); |
725 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 725 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
726 } | 726 } |
727 | 727 |
728 static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) | 728 static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) |
729 { | 729 { |
730 v8::Handle<v8::Object> holder = info.Holder(); | 730 v8::Handle<v8::Object> holder = info.Holder(); |
731 TestObject* impl = V8TestObject::toImpl(holder); | 731 TestObject* impl = V8TestObject::toImpl(holder); |
732 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(inf
o.GetIsolate(), v8Value); | 732 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::O
bject>::Cast(v8Value)); |
733 impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue)); | 733 impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue)); |
734 } | 734 } |
735 | 735 |
736 static void testInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 736 static void testInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
737 { | 737 { |
738 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 738 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
739 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, in
fo); | 739 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, in
fo); |
740 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 740 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
741 } | 741 } |
742 | 742 |
743 static void testObjectAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 743 static void testObjectAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
744 { | 744 { |
745 v8::Handle<v8::Object> holder = info.Holder(); | 745 v8::Handle<v8::Object> holder = info.Holder(); |
746 TestObject* impl = V8TestObject::toImpl(holder); | 746 TestObject* impl = V8TestObject::toImpl(holder); |
747 v8SetReturnValueFast(info, WTF::getPtr(impl->testObjectAttribute()), impl); | 747 v8SetReturnValueFast(info, WTF::getPtr(impl->testObjectAttribute()), impl); |
748 } | 748 } |
749 | 749 |
750 static void testObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 750 static void testObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
751 { | 751 { |
752 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 752 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
753 TestObjectV8Internal::testObjectAttributeAttributeGetter(info); | 753 TestObjectV8Internal::testObjectAttributeAttributeGetter(info); |
754 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 754 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
755 } | 755 } |
756 | 756 |
757 static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 757 static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
758 { | 758 { |
759 v8::Handle<v8::Object> holder = info.Holder(); | 759 v8::Handle<v8::Object> holder = info.Holder(); |
760 TestObject* impl = V8TestObject::toImpl(holder); | 760 TestObject* impl = V8TestObject::toImpl(holder); |
761 TestObject* cppValue = V8TestObject::toImplWithTypeCheck(info.GetIsolate(),
v8Value); | 761 TestObject* cppValue = V8TestObject::toImpl(v8::Handle<v8::Object>::Cast(v8V
alue)); |
762 impl->setTestObjectAttribute(WTF::getPtr(cppValue)); | 762 impl->setTestObjectAttribute(WTF::getPtr(cppValue)); |
763 } | 763 } |
764 | 764 |
765 static void testObjectAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 765 static void testObjectAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
766 { | 766 { |
767 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 767 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
768 TestObjectV8Internal::testObjectAttributeAttributeSetter(v8Value, info); | 768 TestObjectV8Internal::testObjectAttributeAttributeSetter(v8Value, info); |
769 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 769 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
770 } | 770 } |
771 | 771 |
(...skipping 332 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1104 { | 1104 { |
1105 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1105 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1106 TestObjectV8Internal::documentAttributeAttributeGetter(info); | 1106 TestObjectV8Internal::documentAttributeAttributeGetter(info); |
1107 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1107 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1108 } | 1108 } |
1109 | 1109 |
1110 static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) | 1110 static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) |
1111 { | 1111 { |
1112 v8::Handle<v8::Object> holder = info.Holder(); | 1112 v8::Handle<v8::Object> holder = info.Holder(); |
1113 TestObject* impl = V8TestObject::toImpl(holder); | 1113 TestObject* impl = V8TestObject::toImpl(holder); |
1114 Document* cppValue = V8Document::toImplWithTypeCheck(info.GetIsolate(), v8Va
lue); | 1114 Document* cppValue = V8Document::toImpl(v8::Handle<v8::Object>::Cast(v8Value
)); |
1115 impl->setDocumentAttribute(WTF::getPtr(cppValue)); | 1115 impl->setDocumentAttribute(WTF::getPtr(cppValue)); |
1116 } | 1116 } |
1117 | 1117 |
1118 static void documentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1118 static void documentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1119 { | 1119 { |
1120 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1120 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1121 TestObjectV8Internal::documentAttributeAttributeSetter(v8Value, info); | 1121 TestObjectV8Internal::documentAttributeAttributeSetter(v8Value, info); |
1122 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1122 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1123 } | 1123 } |
1124 | 1124 |
1125 static void documentFragmentAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) | 1125 static void documentFragmentAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) |
1126 { | 1126 { |
1127 v8::Handle<v8::Object> holder = info.Holder(); | 1127 v8::Handle<v8::Object> holder = info.Holder(); |
1128 TestObject* impl = V8TestObject::toImpl(holder); | 1128 TestObject* impl = V8TestObject::toImpl(holder); |
1129 v8SetReturnValueFast(info, WTF::getPtr(impl->documentFragmentAttribute()), i
mpl); | 1129 v8SetReturnValueFast(info, WTF::getPtr(impl->documentFragmentAttribute()), i
mpl); |
1130 } | 1130 } |
1131 | 1131 |
1132 static void documentFragmentAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1132 static void documentFragmentAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1133 { | 1133 { |
1134 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1134 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1135 TestObjectV8Internal::documentFragmentAttributeAttributeGetter(info); | 1135 TestObjectV8Internal::documentFragmentAttributeAttributeGetter(info); |
1136 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1136 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1137 } | 1137 } |
1138 | 1138 |
1139 static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Valu
e, const v8::PropertyCallbackInfo<void>& info) | 1139 static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Valu
e, const v8::PropertyCallbackInfo<void>& info) |
1140 { | 1140 { |
1141 v8::Handle<v8::Object> holder = info.Holder(); | 1141 v8::Handle<v8::Object> holder = info.Holder(); |
1142 TestObject* impl = V8TestObject::toImpl(holder); | 1142 TestObject* impl = V8TestObject::toImpl(holder); |
1143 DocumentFragment* cppValue = V8DocumentFragment::toImplWithTypeCheck(info.Ge
tIsolate(), v8Value); | 1143 DocumentFragment* cppValue = V8DocumentFragment::toImpl(v8::Handle<v8::Objec
t>::Cast(v8Value)); |
1144 impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue)); | 1144 impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue)); |
1145 } | 1145 } |
1146 | 1146 |
1147 static void documentFragmentAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1147 static void documentFragmentAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1148 { | 1148 { |
1149 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1149 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1150 TestObjectV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info
); | 1150 TestObjectV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info
); |
1151 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1151 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1152 } | 1152 } |
1153 | 1153 |
1154 static void documentTypeAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) | 1154 static void documentTypeAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) |
1155 { | 1155 { |
1156 v8::Handle<v8::Object> holder = info.Holder(); | 1156 v8::Handle<v8::Object> holder = info.Holder(); |
1157 TestObject* impl = V8TestObject::toImpl(holder); | 1157 TestObject* impl = V8TestObject::toImpl(holder); |
1158 v8SetReturnValueFast(info, WTF::getPtr(impl->documentTypeAttribute()), impl)
; | 1158 v8SetReturnValueFast(info, WTF::getPtr(impl->documentTypeAttribute()), impl)
; |
1159 } | 1159 } |
1160 | 1160 |
1161 static void documentTypeAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 1161 static void documentTypeAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
1162 { | 1162 { |
1163 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1163 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1164 TestObjectV8Internal::documentTypeAttributeAttributeGetter(info); | 1164 TestObjectV8Internal::documentTypeAttributeAttributeGetter(info); |
1165 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1165 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1166 } | 1166 } |
1167 | 1167 |
1168 static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) | 1168 static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) |
1169 { | 1169 { |
1170 v8::Handle<v8::Object> holder = info.Holder(); | 1170 v8::Handle<v8::Object> holder = info.Holder(); |
1171 TestObject* impl = V8TestObject::toImpl(holder); | 1171 TestObject* impl = V8TestObject::toImpl(holder); |
1172 DocumentType* cppValue = V8DocumentType::toImplWithTypeCheck(info.GetIsolate
(), v8Value); | 1172 DocumentType* cppValue = V8DocumentType::toImpl(v8::Handle<v8::Object>::Cast
(v8Value)); |
1173 impl->setDocumentTypeAttribute(WTF::getPtr(cppValue)); | 1173 impl->setDocumentTypeAttribute(WTF::getPtr(cppValue)); |
1174 } | 1174 } |
1175 | 1175 |
1176 static void documentTypeAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1176 static void documentTypeAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1177 { | 1177 { |
1178 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1178 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1179 TestObjectV8Internal::documentTypeAttributeAttributeSetter(v8Value, info); | 1179 TestObjectV8Internal::documentTypeAttributeAttributeSetter(v8Value, info); |
1180 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1180 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1181 } | 1181 } |
1182 | 1182 |
1183 static void elementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::V
alue>& info) | 1183 static void elementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::V
alue>& info) |
1184 { | 1184 { |
1185 v8::Handle<v8::Object> holder = info.Holder(); | 1185 v8::Handle<v8::Object> holder = info.Holder(); |
1186 TestObject* impl = V8TestObject::toImpl(holder); | 1186 TestObject* impl = V8TestObject::toImpl(holder); |
1187 v8SetReturnValueFast(info, WTF::getPtr(impl->elementAttribute()), impl); | 1187 v8SetReturnValueFast(info, WTF::getPtr(impl->elementAttribute()), impl); |
1188 } | 1188 } |
1189 | 1189 |
1190 static void elementAttributeAttributeGetterCallback(v8::Local<v8::String>, const
v8::PropertyCallbackInfo<v8::Value>& info) | 1190 static void elementAttributeAttributeGetterCallback(v8::Local<v8::String>, const
v8::PropertyCallbackInfo<v8::Value>& info) |
1191 { | 1191 { |
1192 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1192 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1193 TestObjectV8Internal::elementAttributeAttributeGetter(info); | 1193 TestObjectV8Internal::elementAttributeAttributeGetter(info); |
1194 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1194 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1195 } | 1195 } |
1196 | 1196 |
1197 static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) | 1197 static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) |
1198 { | 1198 { |
1199 v8::Handle<v8::Object> holder = info.Holder(); | 1199 v8::Handle<v8::Object> holder = info.Holder(); |
1200 TestObject* impl = V8TestObject::toImpl(holder); | 1200 TestObject* impl = V8TestObject::toImpl(holder); |
1201 Element* cppValue = V8Element::toImplWithTypeCheck(info.GetIsolate(), v8Valu
e); | 1201 Element* cppValue = V8Element::toImpl(v8::Handle<v8::Object>::Cast(v8Value))
; |
1202 impl->setElementAttribute(WTF::getPtr(cppValue)); | 1202 impl->setElementAttribute(WTF::getPtr(cppValue)); |
1203 } | 1203 } |
1204 | 1204 |
1205 static void elementAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1205 static void elementAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1206 { | 1206 { |
1207 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1207 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1208 TestObjectV8Internal::elementAttributeAttributeSetter(v8Value, info); | 1208 TestObjectV8Internal::elementAttributeAttributeSetter(v8Value, info); |
1209 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1209 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1210 } | 1210 } |
1211 | 1211 |
1212 static void nodeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Valu
e>& info) | 1212 static void nodeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Valu
e>& info) |
1213 { | 1213 { |
1214 v8::Handle<v8::Object> holder = info.Holder(); | 1214 v8::Handle<v8::Object> holder = info.Holder(); |
1215 TestObject* impl = V8TestObject::toImpl(holder); | 1215 TestObject* impl = V8TestObject::toImpl(holder); |
1216 v8SetReturnValueFast(info, WTF::getPtr(impl->nodeAttribute()), impl); | 1216 v8SetReturnValueFast(info, WTF::getPtr(impl->nodeAttribute()), impl); |
1217 } | 1217 } |
1218 | 1218 |
1219 static void nodeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) | 1219 static void nodeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) |
1220 { | 1220 { |
1221 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1221 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1222 TestObjectV8Internal::nodeAttributeAttributeGetter(info); | 1222 TestObjectV8Internal::nodeAttributeAttributeGetter(info); |
1223 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1223 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1224 } | 1224 } |
1225 | 1225 |
1226 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) | 1226 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) |
1227 { | 1227 { |
1228 v8::Handle<v8::Object> holder = info.Holder(); | 1228 v8::Handle<v8::Object> holder = info.Holder(); |
1229 TestObject* impl = V8TestObject::toImpl(holder); | 1229 TestObject* impl = V8TestObject::toImpl(holder); |
1230 Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value); | 1230 Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
1231 impl->setNodeAttribute(WTF::getPtr(cppValue)); | 1231 impl->setNodeAttribute(WTF::getPtr(cppValue)); |
1232 } | 1232 } |
1233 | 1233 |
1234 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1234 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1235 { | 1235 { |
1236 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1236 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1237 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); | 1237 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); |
1238 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1238 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1239 } | 1239 } |
1240 | 1240 |
1241 static void shadowRootAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 1241 static void shadowRootAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
1242 { | 1242 { |
1243 v8::Handle<v8::Object> holder = info.Holder(); | 1243 v8::Handle<v8::Object> holder = info.Holder(); |
1244 TestObject* impl = V8TestObject::toImpl(holder); | 1244 TestObject* impl = V8TestObject::toImpl(holder); |
1245 v8SetReturnValueFast(info, WTF::getPtr(impl->shadowRootAttribute()), impl); | 1245 v8SetReturnValueFast(info, WTF::getPtr(impl->shadowRootAttribute()), impl); |
1246 } | 1246 } |
1247 | 1247 |
1248 static void shadowRootAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 1248 static void shadowRootAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
1249 { | 1249 { |
1250 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1250 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1251 TestObjectV8Internal::shadowRootAttributeAttributeGetter(info); | 1251 TestObjectV8Internal::shadowRootAttributeAttributeGetter(info); |
1252 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1252 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1253 } | 1253 } |
1254 | 1254 |
1255 static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 1255 static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
1256 { | 1256 { |
1257 v8::Handle<v8::Object> holder = info.Holder(); | 1257 v8::Handle<v8::Object> holder = info.Holder(); |
1258 TestObject* impl = V8TestObject::toImpl(holder); | 1258 TestObject* impl = V8TestObject::toImpl(holder); |
1259 ShadowRoot* cppValue = V8ShadowRoot::toImplWithTypeCheck(info.GetIsolate(),
v8Value); | 1259 ShadowRoot* cppValue = V8ShadowRoot::toImpl(v8::Handle<v8::Object>::Cast(v8V
alue)); |
1260 impl->setShadowRootAttribute(WTF::getPtr(cppValue)); | 1260 impl->setShadowRootAttribute(WTF::getPtr(cppValue)); |
1261 } | 1261 } |
1262 | 1262 |
1263 static void shadowRootAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1263 static void shadowRootAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1264 { | 1264 { |
1265 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1265 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1266 TestObjectV8Internal::shadowRootAttributeAttributeSetter(v8Value, info); | 1266 TestObjectV8Internal::shadowRootAttributeAttributeSetter(v8Value, info); |
1267 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1267 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1268 } | 1268 } |
1269 | 1269 |
(...skipping 334 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1604 { | 1604 { |
1605 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1605 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1606 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeGetter(info); | 1606 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeGetter(info); |
1607 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1607 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1608 } | 1608 } |
1609 | 1609 |
1610 static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8V
alue, const v8::PropertyCallbackInfo<void>& info) | 1610 static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8V
alue, const v8::PropertyCallbackInfo<void>& info) |
1611 { | 1611 { |
1612 v8::Handle<v8::Object> holder = info.Holder(); | 1612 v8::Handle<v8::Object> holder = info.Holder(); |
1613 TestObject* impl = V8TestObject::toImpl(holder); | 1613 TestObject* impl = V8TestObject::toImpl(holder); |
1614 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 1614 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
1615 impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue)); | 1615 impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue)); |
1616 } | 1616 } |
1617 | 1617 |
1618 static void testInterfaceOrNullAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1618 static void testInterfaceOrNullAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1619 { | 1619 { |
1620 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1620 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1621 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, i
nfo); | 1621 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, i
nfo); |
1622 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1622 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1623 } | 1623 } |
1624 | 1624 |
(...skipping 1430 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3055 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3055 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3056 } | 3056 } |
3057 | 3057 |
3058 static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value
, const v8::PropertyCallbackInfo<void>& info) | 3058 static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value
, const v8::PropertyCallbackInfo<void>& info) |
3059 { | 3059 { |
3060 v8::Handle<v8::Object> holder = info.Holder(); | 3060 v8::Handle<v8::Object> holder = info.Holder(); |
3061 TestObject* proxyImpl = V8TestObject::toImpl(holder); | 3061 TestObject* proxyImpl = V8TestObject::toImpl(holder); |
3062 RawPtr<TestInterfaceGarbageCollected> impl = WTF::getPtr(proxyImpl->location
GarbageCollected()); | 3062 RawPtr<TestInterfaceGarbageCollected> impl = WTF::getPtr(proxyImpl->location
GarbageCollected()); |
3063 if (!impl) | 3063 if (!impl) |
3064 return; | 3064 return; |
3065 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); | 3065 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
3066 impl->setAttr1(WTF::getPtr(cppValue)); | 3066 impl->setAttr1(WTF::getPtr(cppValue)); |
3067 } | 3067 } |
3068 | 3068 |
3069 static void locationGarbageCollectedAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3069 static void locationGarbageCollectedAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3070 { | 3070 { |
3071 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3071 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3072 TestObjectV8Internal::locationGarbageCollectedAttributeSetter(v8Value, info)
; | 3072 TestObjectV8Internal::locationGarbageCollectedAttributeSetter(v8Value, info)
; |
3073 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3073 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3074 } | 3074 } |
3075 | 3075 |
(...skipping 18 matching lines...) Expand all Loading... |
3094 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3094 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3095 } | 3095 } |
3096 | 3096 |
3097 static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v
8Value, const v8::PropertyCallbackInfo<void>& info) | 3097 static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v
8Value, const v8::PropertyCallbackInfo<void>& info) |
3098 { | 3098 { |
3099 v8::Handle<v8::Object> holder = info.Holder(); | 3099 v8::Handle<v8::Object> holder = info.Holder(); |
3100 TestObject* proxyImpl = V8TestObject::toImpl(holder); | 3100 TestObject* proxyImpl = V8TestObject::toImpl(holder); |
3101 RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(p
roxyImpl->locationWillBeGarbageCollected()); | 3101 RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(p
roxyImpl->locationWillBeGarbageCollected()); |
3102 if (!impl) | 3102 if (!impl) |
3103 return; | 3103 return; |
3104 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); | 3104 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
3105 impl->setAttr1(WTF::getPtr(cppValue)); | 3105 impl->setAttr1(WTF::getPtr(cppValue)); |
3106 } | 3106 } |
3107 | 3107 |
3108 static void locationWillBeGarbageCollectedAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& inf
o) | 3108 static void locationWillBeGarbageCollectedAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& inf
o) |
3109 { | 3109 { |
3110 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3110 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3111 TestObjectV8Internal::locationWillBeGarbageCollectedAttributeSetter(v8Value,
info); | 3111 TestObjectV8Internal::locationWillBeGarbageCollectedAttributeSetter(v8Value,
info); |
3112 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3112 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3113 } | 3113 } |
3114 | 3114 |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3228 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3228 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3229 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGet
ter(info); | 3229 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGet
ter(info); |
3230 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3230 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3231 } | 3231 } |
3232 | 3232 |
3233 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3233 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3234 { | 3234 { |
3235 v8::Handle<v8::Object> holder = info.Holder(); | 3235 v8::Handle<v8::Object> holder = info.Holder(); |
3236 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nTestInterfaceEmptyAttribute", "TestObject", holder, info.GetIsolate()); | 3236 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nTestInterfaceEmptyAttribute", "TestObject", holder, info.GetIsolate()); |
3237 TestObject* impl = V8TestObject::toImpl(holder); | 3237 TestObject* impl = V8TestObject::toImpl(holder); |
3238 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(inf
o.GetIsolate(), v8Value); | 3238 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::O
bject>::Cast(v8Value)); |
3239 impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), e
xceptionState); | 3239 impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), e
xceptionState); |
3240 exceptionState.throwIfNeeded(); | 3240 exceptionState.throwIfNeeded(); |
3241 } | 3241 } |
3242 | 3242 |
3243 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) | 3243 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) |
3244 { | 3244 { |
3245 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3245 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3246 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSet
ter(v8Value, info); | 3246 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSet
ter(v8Value, info); |
3247 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3247 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3248 } | 3248 } |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3303 { | 3303 { |
3304 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3304 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3305 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeGetter(info); | 3305 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeGetter(info); |
3306 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3306 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3307 } | 3307 } |
3308 | 3308 |
3309 static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) | 3309 static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) |
3310 { | 3310 { |
3311 v8::Handle<v8::Object> holder = info.Holder(); | 3311 v8::Handle<v8::Object> holder = info.Holder(); |
3312 TestObject* impl = V8TestObject::toImpl(holder); | 3312 TestObject* impl = V8TestObject::toImpl(holder); |
3313 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 3313 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
3314 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3314 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3315 impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr
(cppValue)); | 3315 impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr
(cppValue)); |
3316 } | 3316 } |
3317 | 3317 |
3318 static void reflectTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) | 3318 static void reflectTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) |
3319 { | 3319 { |
3320 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3320 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3321 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3321 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3322 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value,
info); | 3322 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value,
info); |
3323 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3323 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 10 matching lines...) Expand all Loading... |
3334 { | 3334 { |
3335 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3335 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3336 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGet
ter(info); | 3336 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGet
ter(info); |
3337 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3337 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3338 } | 3338 } |
3339 | 3339 |
3340 static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3340 static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3341 { | 3341 { |
3342 v8::Handle<v8::Object> holder = info.Holder(); | 3342 v8::Handle<v8::Object> holder = info.Holder(); |
3343 TestObject* impl = V8TestObject::toImpl(holder); | 3343 TestObject* impl = V8TestObject::toImpl(holder); |
3344 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 3344 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
3345 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3345 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3346 impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppVal
ue)); | 3346 impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppVal
ue)); |
3347 } | 3347 } |
3348 | 3348 |
3349 static void reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) | 3349 static void reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) |
3350 { | 3350 { |
3351 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3351 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3352 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3352 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3353 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSet
ter(v8Value, info); | 3353 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSet
ter(v8Value, info); |
3354 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3354 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 1101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4456 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetter(v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4456 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetter(v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4457 { | 4457 { |
4458 v8::Handle<v8::Object> holder = info.Holder(); | 4458 v8::Handle<v8::Object> holder = info.Holder(); |
4459 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceAttribute", "TestObject", holder, info.GetIsolate()); | 4459 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceAttribute", "TestObject", holder, info.GetIsolate()); |
4460 if (!V8TestInterface::hasInstance(v8Value, info.GetIsolate())) { | 4460 if (!V8TestInterface::hasInstance(v8Value, info.GetIsolate())) { |
4461 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); | 4461 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); |
4462 exceptionState.throwIfNeeded(); | 4462 exceptionState.throwIfNeeded(); |
4463 return; | 4463 return; |
4464 } | 4464 } |
4465 TestObject* impl = V8TestObject::toImpl(holder); | 4465 TestObject* impl = V8TestObject::toImpl(holder); |
4466 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 4466 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
4467 impl->setTypeCheckingInterfaceTestInterfaceAttribute(WTF::getPtr(cppValue)); | 4467 impl->setTypeCheckingInterfaceTestInterfaceAttribute(WTF::getPtr(cppValue)); |
4468 } | 4468 } |
4469 | 4469 |
4470 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetterCallback(v
8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackIn
fo<void>& info) | 4470 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetterCallback(v
8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackIn
fo<void>& info) |
4471 { | 4471 { |
4472 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4472 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4473 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceAttributeAttributeSe
tter(v8Value, info); | 4473 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceAttributeAttributeSe
tter(v8Value, info); |
4474 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4474 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4475 } | 4475 } |
4476 | 4476 |
(...skipping 14 matching lines...) Expand all Loading... |
4491 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetter(v8:
:Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4491 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetter(v8:
:Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4492 { | 4492 { |
4493 v8::Handle<v8::Object> holder = info.Holder(); | 4493 v8::Handle<v8::Object> holder = info.Holder(); |
4494 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceOrNullAttribute", "TestObject", holder, info.GetIsolate()); | 4494 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceOrNullAttribute", "TestObject", holder, info.GetIsolate()); |
4495 if (!isUndefinedOrNull(v8Value) && !V8TestInterface::hasInstance(v8Value, in
fo.GetIsolate())) { | 4495 if (!isUndefinedOrNull(v8Value) && !V8TestInterface::hasInstance(v8Value, in
fo.GetIsolate())) { |
4496 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); | 4496 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); |
4497 exceptionState.throwIfNeeded(); | 4497 exceptionState.throwIfNeeded(); |
4498 return; | 4498 return; |
4499 } | 4499 } |
4500 TestObject* impl = V8TestObject::toImpl(holder); | 4500 TestObject* impl = V8TestObject::toImpl(holder); |
4501 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 4501 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
4502 impl->setTypeCheckingInterfaceTestInterfaceOrNullAttribute(WTF::getPtr(cppVa
lue)); | 4502 impl->setTypeCheckingInterfaceTestInterfaceOrNullAttribute(WTF::getPtr(cppVa
lue)); |
4503 } | 4503 } |
4504 | 4504 |
4505 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetterCall
back(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCall
backInfo<void>& info) | 4505 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetterCall
back(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCall
backInfo<void>& info) |
4506 { | 4506 { |
4507 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4507 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4508 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceOrNullAttributeAttri
buteSetter(v8Value, info); | 4508 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceOrNullAttributeAttri
buteSetter(v8Value, info); |
4509 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4509 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4510 } | 4510 } |
4511 | 4511 |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4612 { | 4612 { |
4613 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4613 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4614 TestObjectV8Internal::testInterfaceAttributeAttributeGetter(info); | 4614 TestObjectV8Internal::testInterfaceAttributeAttributeGetter(info); |
4615 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4615 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4616 } | 4616 } |
4617 | 4617 |
4618 static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) | 4618 static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) |
4619 { | 4619 { |
4620 v8::Handle<v8::Object> holder = info.Holder(); | 4620 v8::Handle<v8::Object> holder = info.Holder(); |
4621 TestObject* impl = V8TestObject::toImpl(holder); | 4621 TestObject* impl = V8TestObject::toImpl(holder); |
4622 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); | 4622 TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v
8::Object>::Cast(v8Value)); |
4623 impl->setTestInterfaceAttribute(WTF::getPtr(cppValue)); | 4623 impl->setTestInterfaceAttribute(WTF::getPtr(cppValue)); |
4624 } | 4624 } |
4625 | 4625 |
4626 static void testInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4626 static void testInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4627 { | 4627 { |
4628 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4628 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4629 TestObjectV8Internal::testInterfaceAttributeAttributeSetter(v8Value, info); | 4629 TestObjectV8Internal::testInterfaceAttributeAttributeSetter(v8Value, info); |
4630 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4630 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4631 } | 4631 } |
4632 | 4632 |
4633 static void testInterfaceGarbageCollectedAttributeAttributeGetter(const v8::Prop
ertyCallbackInfo<v8::Value>& info) | 4633 static void testInterfaceGarbageCollectedAttributeAttributeGetter(const v8::Prop
ertyCallbackInfo<v8::Value>& info) |
4634 { | 4634 { |
4635 v8::Handle<v8::Object> holder = info.Holder(); | 4635 v8::Handle<v8::Object> holder = info.Holder(); |
4636 TestObject* impl = V8TestObject::toImpl(holder); | 4636 TestObject* impl = V8TestObject::toImpl(holder); |
4637 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedAt
tribute()), impl); | 4637 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedAt
tribute()), impl); |
4638 } | 4638 } |
4639 | 4639 |
4640 static void testInterfaceGarbageCollectedAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4640 static void testInterfaceGarbageCollectedAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4641 { | 4641 { |
4642 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4642 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4643 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeGetter(
info); | 4643 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeGetter(
info); |
4644 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4644 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4645 } | 4645 } |
4646 | 4646 |
4647 static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::
Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4647 static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::
Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4648 { | 4648 { |
4649 v8::Handle<v8::Object> holder = info.Holder(); | 4649 v8::Handle<v8::Object> holder = info.Holder(); |
4650 TestObject* impl = V8TestObject::toImpl(holder); | 4650 TestObject* impl = V8TestObject::toImpl(holder); |
4651 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); | 4651 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
4652 impl->setTestInterfaceGarbageCollectedAttribute(WTF::getPtr(cppValue)); | 4652 impl->setTestInterfaceGarbageCollectedAttribute(WTF::getPtr(cppValue)); |
4653 } | 4653 } |
4654 | 4654 |
4655 static void testInterfaceGarbageCollectedAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<vo
id>& info) | 4655 static void testInterfaceGarbageCollectedAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<vo
id>& info) |
4656 { | 4656 { |
4657 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4657 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4658 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeSetter(
v8Value, info); | 4658 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeSetter(
v8Value, info); |
4659 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4659 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4660 } | 4660 } |
4661 | 4661 |
4662 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) | 4662 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) |
4663 { | 4663 { |
4664 v8::Handle<v8::Object> holder = info.Holder(); | 4664 v8::Handle<v8::Object> holder = info.Holder(); |
4665 TestObject* impl = V8TestObject::toImpl(holder); | 4665 TestObject* impl = V8TestObject::toImpl(holder); |
4666 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedOr
NullAttribute()), impl); | 4666 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedOr
NullAttribute()), impl); |
4667 } | 4667 } |
4668 | 4668 |
4669 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4669 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4670 { | 4670 { |
4671 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4671 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4672 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeG
etter(info); | 4672 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeG
etter(info); |
4673 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4673 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4674 } | 4674 } |
4675 | 4675 |
4676 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4676 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4677 { | 4677 { |
4678 v8::Handle<v8::Object> holder = info.Holder(); | 4678 v8::Handle<v8::Object> holder = info.Holder(); |
4679 TestObject* impl = V8TestObject::toImpl(holder); | 4679 TestObject* impl = V8TestObject::toImpl(holder); |
4680 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); | 4680 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
4681 impl->setTestInterfaceGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue))
; | 4681 impl->setTestInterfaceGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue))
; |
4682 } | 4682 } |
4683 | 4683 |
4684 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) | 4684 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) |
4685 { | 4685 { |
4686 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4686 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4687 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeS
etter(v8Value, info); | 4687 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeS
etter(v8Value, info); |
4688 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4688 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4689 } | 4689 } |
4690 | 4690 |
4691 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) | 4691 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) |
4692 { | 4692 { |
4693 v8::Handle<v8::Object> holder = info.Holder(); | 4693 v8::Handle<v8::Object> holder = info.Holder(); |
4694 TestObject* impl = V8TestObject::toImpl(holder); | 4694 TestObject* impl = V8TestObject::toImpl(holder); |
4695 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedAttribute()), impl); | 4695 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedAttribute()), impl); |
4696 } | 4696 } |
4697 | 4697 |
4698 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4698 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4699 { | 4699 { |
4700 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4700 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4701 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeG
etter(info); | 4701 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeG
etter(info); |
4702 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4702 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4703 } | 4703 } |
4704 | 4704 |
4705 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4705 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4706 { | 4706 { |
4707 v8::Handle<v8::Object> holder = info.Holder(); | 4707 v8::Handle<v8::Object> holder = info.Holder(); |
4708 TestObject* impl = V8TestObject::toImpl(holder); | 4708 TestObject* impl = V8TestObject::toImpl(holder); |
4709 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); | 4709 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
4710 impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue))
; | 4710 impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue))
; |
4711 } | 4711 } |
4712 | 4712 |
4713 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) | 4713 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) |
4714 { | 4714 { |
4715 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4715 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4716 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeS
etter(v8Value, info); | 4716 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeS
etter(v8Value, info); |
4717 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4717 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4718 } | 4718 } |
4719 | 4719 |
4720 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 4720 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
4721 { | 4721 { |
4722 v8::Handle<v8::Object> holder = info.Holder(); | 4722 v8::Handle<v8::Object> holder = info.Holder(); |
4723 TestObject* impl = V8TestObject::toImpl(holder); | 4723 TestObject* impl = V8TestObject::toImpl(holder); |
4724 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedOrNullAttribute()), impl); | 4724 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedOrNullAttribute()), impl); |
4725 } | 4725 } |
4726 | 4726 |
4727 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4727 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4728 { | 4728 { |
4729 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4729 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4730 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteGetter(info); | 4730 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteGetter(info); |
4731 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4731 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4732 } | 4732 } |
4733 | 4733 |
4734 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4734 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4735 { | 4735 { |
4736 v8::Handle<v8::Object> holder = info.Holder(); | 4736 v8::Handle<v8::Object> holder = info.Holder(); |
4737 TestObject* impl = V8TestObject::toImpl(holder); | 4737 TestObject* impl = V8TestObject::toImpl(holder); |
4738 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); | 4738 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
4739 impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppV
alue)); | 4739 impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppV
alue)); |
4740 } | 4740 } |
4741 | 4741 |
4742 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) | 4742 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) |
4743 { | 4743 { |
4744 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4744 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4745 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteSetter(v8Value, info); | 4745 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteSetter(v8Value, info); |
4746 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4746 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4747 } | 4747 } |
4748 | 4748 |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4842 { | 4842 { |
4843 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4843 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4844 TestObjectV8Internal::nodeAttributeAttributeGetter(info); | 4844 TestObjectV8Internal::nodeAttributeAttributeGetter(info); |
4845 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4845 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4846 } | 4846 } |
4847 | 4847 |
4848 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) | 4848 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) |
4849 { | 4849 { |
4850 v8::Handle<v8::Object> holder = info.Holder(); | 4850 v8::Handle<v8::Object> holder = info.Holder(); |
4851 TestObject* impl = V8TestObject::toImpl(holder); | 4851 TestObject* impl = V8TestObject::toImpl(holder); |
4852 Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value); | 4852 Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
4853 V8TestObject::PrivateScript::nodeAttributeAttributeSetter(toFrameIfNotDetach
ed(info.GetIsolate()->GetCurrentContext()), impl, cppValue); | 4853 V8TestObject::PrivateScript::nodeAttributeAttributeSetter(toFrameIfNotDetach
ed(info.GetIsolate()->GetCurrentContext()), impl, cppValue); |
4854 } | 4854 } |
4855 | 4855 |
4856 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4856 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4857 { | 4857 { |
4858 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4858 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4859 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); | 4859 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); |
4860 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4860 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4861 } | 4861 } |
4862 | 4862 |
(...skipping 708 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5571 | 5571 |
5572 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 5572 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
5573 { | 5573 { |
5574 if (UNLIKELY(info.Length() < 1)) { | 5574 if (UNLIKELY(info.Length() < 1)) { |
5575 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate
()), info.GetIsolate()); | 5575 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate
()), info.GetIsolate()); |
5576 return; | 5576 return; |
5577 } | 5577 } |
5578 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5578 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5579 TestInterfaceEmpty* testInterfaceEmptyArg; | 5579 TestInterfaceEmpty* testInterfaceEmptyArg; |
5580 { | 5580 { |
5581 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 5581 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
5582 } | 5582 } |
5583 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); | 5583 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); |
5584 } | 5584 } |
5585 | 5585 |
5586 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 5586 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
5587 { | 5587 { |
5588 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5588 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5589 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); | 5589 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); |
5590 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5590 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5591 } | 5591 } |
5592 | 5592 |
5593 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 5593 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
5594 { | 5594 { |
5595 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); | 5595 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); |
5596 if (UNLIKELY(info.Length() < 2)) { | 5596 if (UNLIKELY(info.Length() < 2)) { |
5597 setMinimumArityTypeError(exceptionState, 2, info.Length()); | 5597 setMinimumArityTypeError(exceptionState, 2, info.Length()); |
5598 exceptionState.throwIfNeeded(); | 5598 exceptionState.throwIfNeeded(); |
5599 return; | 5599 return; |
5600 } | 5600 } |
5601 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5601 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5602 int longArg; | 5602 int longArg; |
5603 TestInterfaceEmpty* testInterfaceEmptyArg; | 5603 TestInterfaceEmpty* testInterfaceEmptyArg; |
5604 { | 5604 { |
5605 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 5605 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
5606 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[1]); | 5606 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[1])); |
5607 } | 5607 } |
5608 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg)
; | 5608 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg)
; |
5609 } | 5609 } |
5610 | 5610 |
5611 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 5611 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
5612 { | 5612 { |
5613 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5613 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5614 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info); | 5614 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info); |
5615 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5615 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5616 } | 5616 } |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5740 | 5740 |
5741 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5741 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
5742 { | 5742 { |
5743 if (UNLIKELY(info.Length() < 1)) { | 5743 if (UNLIKELY(info.Length() < 1)) { |
5744 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAttrArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); | 5744 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAttrArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); |
5745 return; | 5745 return; |
5746 } | 5746 } |
5747 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5747 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5748 Attr* attrArg; | 5748 Attr* attrArg; |
5749 { | 5749 { |
5750 attrArg = V8Attr::toImplWithTypeCheck(info.GetIsolate(), info[0]); | 5750 attrArg = V8Attr::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
5751 } | 5751 } |
5752 impl->voidMethodAttrArg(attrArg); | 5752 impl->voidMethodAttrArg(attrArg); |
5753 } | 5753 } |
5754 | 5754 |
5755 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5755 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5756 { | 5756 { |
5757 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5757 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5758 TestObjectV8Internal::voidMethodAttrArgMethod(info); | 5758 TestObjectV8Internal::voidMethodAttrArgMethod(info); |
5759 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5759 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5760 } | 5760 } |
5761 | 5761 |
5762 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 5762 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
5763 { | 5763 { |
5764 if (UNLIKELY(info.Length() < 1)) { | 5764 if (UNLIKELY(info.Length() < 1)) { |
5765 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.
GetIsolate()); | 5765 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.
GetIsolate()); |
5766 return; | 5766 return; |
5767 } | 5767 } |
5768 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5768 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5769 Document* documentArg; | 5769 Document* documentArg; |
5770 { | 5770 { |
5771 documentArg = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]
); | 5771 documentArg = V8Document::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
5772 } | 5772 } |
5773 impl->voidMethodDocumentArg(documentArg); | 5773 impl->voidMethodDocumentArg(documentArg); |
5774 } | 5774 } |
5775 | 5775 |
5776 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 5776 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
5777 { | 5777 { |
5778 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5778 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5779 TestObjectV8Internal::voidMethodDocumentArgMethod(info); | 5779 TestObjectV8Internal::voidMethodDocumentArgMethod(info); |
5780 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5780 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5781 } | 5781 } |
5782 | 5782 |
5783 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5783 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5784 { | 5784 { |
5785 if (UNLIKELY(info.Length() < 1)) { | 5785 if (UNLIKELY(info.Length() < 1)) { |
5786 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); | 5786 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); |
5787 return; | 5787 return; |
5788 } | 5788 } |
5789 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5789 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5790 DocumentType* documentTypeArg; | 5790 DocumentType* documentTypeArg; |
5791 { | 5791 { |
5792 documentTypeArg = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(),
info[0]); | 5792 documentTypeArg = V8DocumentType::toImpl(v8::Handle<v8::Object>::Cast(in
fo[0])); |
5793 } | 5793 } |
5794 impl->voidMethodDocumentTypeArg(documentTypeArg); | 5794 impl->voidMethodDocumentTypeArg(documentTypeArg); |
5795 } | 5795 } |
5796 | 5796 |
5797 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 5797 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
5798 { | 5798 { |
5799 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5799 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5800 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info); | 5800 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info); |
5801 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5801 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5802 } | 5802 } |
5803 | 5803 |
5804 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 5804 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
5805 { | 5805 { |
5806 if (UNLIKELY(info.Length() < 1)) { | 5806 if (UNLIKELY(info.Length() < 1)) { |
5807 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodElementArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); | 5807 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodElementArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); |
5808 return; | 5808 return; |
5809 } | 5809 } |
5810 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5810 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5811 Element* elementArg; | 5811 Element* elementArg; |
5812 { | 5812 { |
5813 elementArg = V8Element::toImplWithTypeCheck(info.GetIsolate(), info[0]); | 5813 elementArg = V8Element::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
5814 } | 5814 } |
5815 impl->voidMethodElementArg(elementArg); | 5815 impl->voidMethodElementArg(elementArg); |
5816 } | 5816 } |
5817 | 5817 |
5818 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 5818 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
5819 { | 5819 { |
5820 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5820 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5821 TestObjectV8Internal::voidMethodElementArgMethod(info); | 5821 TestObjectV8Internal::voidMethodElementArgMethod(info); |
5822 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5822 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5823 } | 5823 } |
5824 | 5824 |
5825 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5825 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
5826 { | 5826 { |
5827 if (UNLIKELY(info.Length() < 1)) { | 5827 if (UNLIKELY(info.Length() < 1)) { |
5828 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodNodeArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); | 5828 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodNodeArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); |
5829 return; | 5829 return; |
5830 } | 5830 } |
5831 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5831 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5832 Node* nodeArg; | 5832 Node* nodeArg; |
5833 { | 5833 { |
5834 nodeArg = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]); | 5834 nodeArg = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
5835 } | 5835 } |
5836 impl->voidMethodNodeArg(nodeArg); | 5836 impl->voidMethodNodeArg(nodeArg); |
5837 } | 5837 } |
5838 | 5838 |
5839 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5839 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5840 { | 5840 { |
5841 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5841 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5842 TestObjectV8Internal::voidMethodNodeArgMethod(info); | 5842 TestObjectV8Internal::voidMethodNodeArgMethod(info); |
5843 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5843 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5844 } | 5844 } |
(...skipping 567 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6412 | 6412 |
6413 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 6413 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
6414 { | 6414 { |
6415 if (UNLIKELY(info.Length() < 1)) { | 6415 if (UNLIKELY(info.Length() < 1)) { |
6416 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetI
solate()), info.GetIsolate()); | 6416 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetI
solate()), info.GetIsolate()); |
6417 return; | 6417 return; |
6418 } | 6418 } |
6419 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6419 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6420 TestInterfaceEmpty* nullableTestInterfaceEmptyArg; | 6420 TestInterfaceEmpty* nullableTestInterfaceEmptyArg; |
6421 { | 6421 { |
6422 nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeChec
k(info.GetIsolate(), info[0]); | 6422 nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<
v8::Object>::Cast(info[0])); |
6423 } | 6423 } |
6424 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg); | 6424 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg); |
6425 } | 6425 } |
6426 | 6426 |
6427 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi
onCallbackInfo<v8::Value>& info) | 6427 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi
onCallbackInfo<v8::Value>& info) |
6428 { | 6428 { |
6429 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6429 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6430 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info); | 6430 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info); |
6431 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6431 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6432 } | 6432 } |
(...skipping 465 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6898 | 6898 |
6899 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 6899 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
6900 { | 6900 { |
6901 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6901 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6902 TestInterfaceEmpty* optionalTestInterfaceEmptyArg; | 6902 TestInterfaceEmpty* optionalTestInterfaceEmptyArg; |
6903 { | 6903 { |
6904 if (UNLIKELY(info.Length() <= 0)) { | 6904 if (UNLIKELY(info.Length() <= 0)) { |
6905 impl->voidMethodOptionalTestInterfaceEmptyArg(); | 6905 impl->voidMethodOptionalTestInterfaceEmptyArg(); |
6906 return; | 6906 return; |
6907 } | 6907 } |
6908 optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeChec
k(info.GetIsolate(), info[0]); | 6908 optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<
v8::Object>::Cast(info[0])); |
6909 } | 6909 } |
6910 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg)
; | 6910 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg)
; |
6911 } | 6911 } |
6912 | 6912 |
6913 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 6913 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
6914 { | 6914 { |
6915 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6915 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6916 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info); | 6916 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info); |
6917 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6917 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6918 } | 6918 } |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7079 } | 7079 } |
7080 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7080 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7081 int longArg; | 7081 int longArg; |
7082 TestInterfaceEmpty* optionalTestInterfaceEmpty; | 7082 TestInterfaceEmpty* optionalTestInterfaceEmpty; |
7083 { | 7083 { |
7084 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7084 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7085 if (UNLIKELY(info.Length() <= 1)) { | 7085 if (UNLIKELY(info.Length() <= 1)) { |
7086 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); | 7086 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); |
7087 return; | 7087 return; |
7088 } | 7088 } |
7089 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(i
nfo.GetIsolate(), info[1]); | 7089 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImpl(v8::Handle<v8:
:Object>::Cast(info[1])); |
7090 } | 7090 } |
7091 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn
terfaceEmpty); | 7091 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn
terfaceEmpty); |
7092 } | 7092 } |
7093 | 7093 |
7094 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 7094 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
7095 { | 7095 { |
7096 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7096 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7097 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i
nfo); | 7097 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i
nfo); |
7098 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7098 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7099 } | 7099 } |
7100 | 7100 |
7101 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 7101 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
7102 { | 7102 { |
7103 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola
te()); | 7103 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola
te()); |
7104 if (UNLIKELY(info.Length() < 1)) { | 7104 if (UNLIKELY(info.Length() < 1)) { |
7105 setMinimumArityTypeError(exceptionState, 1, info.Length()); | 7105 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
7106 exceptionState.throwIfNeeded(); | 7106 exceptionState.throwIfNeeded(); |
7107 return; | 7107 return; |
7108 } | 7108 } |
7109 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7109 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7110 TestInterfaceEmpty* optionalTestInterfaceEmpty; | 7110 TestInterfaceEmpty* optionalTestInterfaceEmpty; |
7111 int longArg; | 7111 int longArg; |
7112 { | 7112 { |
7113 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(i
nfo.GetIsolate(), info[0]); | 7113 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImpl(v8::Handle<v8:
:Object>::Cast(info[0])); |
7114 if (UNLIKELY(info.Length() <= 1)) { | 7114 if (UNLIKELY(info.Length() <= 1)) { |
7115 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInt
erfaceEmpty); | 7115 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInt
erfaceEmpty); |
7116 return; | 7116 return; |
7117 } | 7117 } |
7118 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[1], exceptio
nState), exceptionState); | 7118 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[1], exceptio
nState), exceptionState); |
7119 } | 7119 } |
7120 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm
pty, longArg); | 7120 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm
pty, longArg); |
7121 } | 7121 } |
7122 | 7122 |
7123 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 7123 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
(...skipping 207 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7331 TestObjectV8Internal::voidMethodDefaultNullableStringArgMethod(info); | 7331 TestObjectV8Internal::voidMethodDefaultNullableStringArgMethod(info); |
7332 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7332 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7333 } | 7333 } |
7334 | 7334 |
7335 static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCa
llbackInfo<v8::Value>& info) | 7335 static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCa
llbackInfo<v8::Value>& info) |
7336 { | 7336 { |
7337 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7337 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7338 TestInterfaceImplementation* defaultTestInterfaceArg; | 7338 TestInterfaceImplementation* defaultTestInterfaceArg; |
7339 { | 7339 { |
7340 if (!info[0]->IsUndefined()) { | 7340 if (!info[0]->IsUndefined()) { |
7341 defaultTestInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.
GetIsolate(), info[0]); | 7341 defaultTestInterfaceArg = V8TestInterface::toImpl(v8::Handle<v8::Obj
ect>::Cast(info[0])); |
7342 } else { | 7342 } else { |
7343 defaultTestInterfaceArg = nullptr; | 7343 defaultTestInterfaceArg = nullptr; |
7344 } | 7344 } |
7345 } | 7345 } |
7346 impl->voidMethodDefaultNullableTestInterfaceArg(defaultTestInterfaceArg); | 7346 impl->voidMethodDefaultNullableTestInterfaceArg(defaultTestInterfaceArg); |
7347 } | 7347 } |
7348 | 7348 |
7349 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) | 7349 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) |
7350 { | 7350 { |
7351 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7351 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7426 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", info.Holder(),
info.GetIsolate()); | 7426 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", info.Holder(),
info.GetIsolate()); |
7427 if (UNLIKELY(info.Length() < 1)) { | 7427 if (UNLIKELY(info.Length() < 1)) { |
7428 setMinimumArityTypeError(exceptionState, 1, info.Length()); | 7428 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
7429 exceptionState.throwIfNeeded(); | 7429 exceptionState.throwIfNeeded(); |
7430 return; | 7430 return; |
7431 } | 7431 } |
7432 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7432 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7433 TestInterfaceEmpty* testInterfaceEmptyArg; | 7433 TestInterfaceEmpty* testInterfaceEmptyArg; |
7434 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; | 7434 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; |
7435 { | 7435 { |
7436 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 7436 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
7437 for (int i = 1; i < info.Length(); ++i) { | 7437 for (int i = 1; i < info.Length(); ++i) { |
7438 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ | 7438 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ |
7439 exceptionState.throwTypeError("parameter 2 is not of type 'TestI
nterfaceEmpty'."); | 7439 exceptionState.throwTypeError("parameter 2 is not of type 'TestI
nterfaceEmpty'."); |
7440 exceptionState.throwIfNeeded(); | 7440 exceptionState.throwIfNeeded(); |
7441 return; | 7441 return; |
7442 } | 7442 } |
7443 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); | 7443 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); |
7444 } | 7444 } |
7445 } | 7445 } |
7446 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); | 7446 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); |
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7636 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7636 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7637 } | 7637 } |
7638 impl->overloadedMethodC(longArg); | 7638 impl->overloadedMethodC(longArg); |
7639 } | 7639 } |
7640 | 7640 |
7641 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7641 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7642 { | 7642 { |
7643 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7643 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7644 TestInterfaceEmpty* testInterfaceEmptyArg; | 7644 TestInterfaceEmpty* testInterfaceEmptyArg; |
7645 { | 7645 { |
7646 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 7646 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
7647 } | 7647 } |
7648 impl->overloadedMethodC(testInterfaceEmptyArg); | 7648 impl->overloadedMethodC(testInterfaceEmptyArg); |
7649 } | 7649 } |
7650 | 7650 |
7651 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7651 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7652 { | 7652 { |
7653 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObject", info.Holder(), info.GetIsolate()); | 7653 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObject", info.Holder(), info.GetIsolate()); |
7654 switch (std::min(1, info.Length())) { | 7654 switch (std::min(1, info.Length())) { |
7655 case 1: | 7655 case 1: |
7656 if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) { | 7656 if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) { |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7739 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7739 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7740 } | 7740 } |
7741 impl->overloadedMethodE(longArg); | 7741 impl->overloadedMethodE(longArg); |
7742 } | 7742 } |
7743 | 7743 |
7744 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7744 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7745 { | 7745 { |
7746 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7746 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7747 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; | 7747 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; |
7748 { | 7748 { |
7749 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(
info.GetIsolate(), info[0]); | 7749 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8
::Object>::Cast(info[0])); |
7750 } | 7750 } |
7751 impl->overloadedMethodE(testInterfaceEmptyOrNullArg); | 7751 impl->overloadedMethodE(testInterfaceEmptyOrNullArg); |
7752 } | 7752 } |
7753 | 7753 |
7754 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7754 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7755 { | 7755 { |
7756 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodE", "TestObject", info.Holder(), info.GetIsolate()); | 7756 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodE", "TestObject", info.Holder(), info.GetIsolate()); |
7757 switch (std::min(1, info.Length())) { | 7757 switch (std::min(1, info.Length())) { |
7758 case 1: | 7758 case 1: |
7759 if (isUndefinedOrNull(info[0])) { | 7759 if (isUndefinedOrNull(info[0])) { |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7864 } | 7864 } |
7865 impl->overloadedMethodG(longArg); | 7865 impl->overloadedMethodG(longArg); |
7866 } | 7866 } |
7867 | 7867 |
7868 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7868 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7869 { | 7869 { |
7870 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7870 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7871 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; | 7871 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; |
7872 { | 7872 { |
7873 if (!info[0]->IsUndefined()) { | 7873 if (!info[0]->IsUndefined()) { |
7874 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCh
eck(info.GetIsolate(), info[0]); | 7874 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handl
e<v8::Object>::Cast(info[0])); |
7875 } else { | 7875 } else { |
7876 testInterfaceEmptyOrNullArg = nullptr; | 7876 testInterfaceEmptyOrNullArg = nullptr; |
7877 } | 7877 } |
7878 } | 7878 } |
7879 impl->overloadedMethodG(testInterfaceEmptyOrNullArg); | 7879 impl->overloadedMethodG(testInterfaceEmptyOrNullArg); |
7880 } | 7880 } |
7881 | 7881 |
7882 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7882 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7883 { | 7883 { |
7884 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodG", "TestObject", info.Holder(), info.GetIsolate()); | 7884 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodG", "TestObject", info.Holder(), info.GetIsolate()); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7921 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7921 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7922 TestObjectV8Internal::overloadedMethodGMethod(info); | 7922 TestObjectV8Internal::overloadedMethodGMethod(info); |
7923 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7923 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7924 } | 7924 } |
7925 | 7925 |
7926 static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7926 static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7927 { | 7927 { |
7928 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7928 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7929 TestInterfaceImplementation* testInterfaceArg; | 7929 TestInterfaceImplementation* testInterfaceArg; |
7930 { | 7930 { |
7931 testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(
), info[0]); | 7931 testInterfaceArg = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(
info[0])); |
7932 } | 7932 } |
7933 impl->overloadedMethodH(testInterfaceArg); | 7933 impl->overloadedMethodH(testInterfaceArg); |
7934 } | 7934 } |
7935 | 7935 |
7936 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7936 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7937 { | 7937 { |
7938 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7938 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7939 TestInterfaceEmpty* testInterfaceEmptyArg; | 7939 TestInterfaceEmpty* testInterfaceEmptyArg; |
7940 { | 7940 { |
7941 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 7941 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
7942 } | 7942 } |
7943 impl->overloadedMethodH(testInterfaceEmptyArg); | 7943 impl->overloadedMethodH(testInterfaceEmptyArg); |
7944 } | 7944 } |
7945 | 7945 |
7946 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7946 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7947 { | 7947 { |
7948 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodH", "TestObject", info.Holder(), info.GetIsolate()); | 7948 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodH", "TestObject", info.Holder(), info.GetIsolate()); |
7949 switch (std::min(1, info.Length())) { | 7949 switch (std::min(1, info.Length())) { |
7950 case 1: | 7950 case 1: |
7951 if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) { | 7951 if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) { |
(...skipping 332 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8284 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8284 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8285 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info); | 8285 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info); |
8286 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8286 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8287 } | 8287 } |
8288 | 8288 |
8289 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 8289 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
8290 { | 8290 { |
8291 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 8291 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8292 TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg; | 8292 TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg; |
8293 { | 8293 { |
8294 defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWith
TypeCheck(info.GetIsolate(), info[0]); | 8294 defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8:
:Handle<v8::Object>::Cast(info[0])); |
8295 } | 8295 } |
8296 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn
terfaceEmptyArg); | 8296 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn
terfaceEmptyArg); |
8297 } | 8297 } |
8298 | 8298 |
8299 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 8299 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
8300 { | 8300 { |
8301 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8301 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8302 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(
info); | 8302 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(
info); |
8303 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8303 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8304 } | 8304 } |
(...skipping 809 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9114 | 9114 |
9115 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 9115 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
9116 { | 9116 { |
9117 if (UNLIKELY(info.Length() < 1)) { | 9117 if (UNLIKELY(info.Length() < 1)) { |
9118 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); | 9118 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); |
9119 return; | 9119 return; |
9120 } | 9120 } |
9121 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9121 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9122 TestInterfaceEmpty* testInterfaceEmptyArg; | 9122 TestInterfaceEmpty* testInterfaceEmptyArg; |
9123 { | 9123 { |
9124 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 9124 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
9125 } | 9125 } |
9126 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; | 9126 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; |
9127 } | 9127 } |
9128 | 9128 |
9129 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9129 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
9130 { | 9130 { |
9131 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9131 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9132 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(
info); | 9132 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(
info); |
9133 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9133 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9134 } | 9134 } |
9135 | 9135 |
9136 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) | 9136 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) |
9137 { | 9137 { |
9138 if (UNLIKELY(info.Length() < 1)) { | 9138 if (UNLIKELY(info.Length() < 1)) { |
9139 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); | 9139 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); |
9140 return; | 9140 return; |
9141 } | 9141 } |
9142 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9142 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9143 TestInterfaceEmpty* testInterfaceEmptyArg; | 9143 TestInterfaceEmpty* testInterfaceEmptyArg; |
9144 { | 9144 { |
9145 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 9145 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
9146 } | 9146 } |
9147 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; | 9147 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; |
9148 } | 9148 } |
9149 | 9149 |
9150 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) | 9150 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) |
9151 { | 9151 { |
9152 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9152 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9153 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF
orMainWorld(info); | 9153 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF
orMainWorld(info); |
9154 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9154 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9155 } | 9155 } |
(...skipping 350 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9506 TOSTRING_VOID_INTERNAL(stringArg, info[0]); | 9506 TOSTRING_VOID_INTERNAL(stringArg, info[0]); |
9507 } | 9507 } |
9508 impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg); | 9508 impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg); |
9509 } | 9509 } |
9510 | 9510 |
9511 static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::Functio
nCallbackInfo<v8::Value>& info) | 9511 static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::Functio
nCallbackInfo<v8::Value>& info) |
9512 { | 9512 { |
9513 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9513 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9514 TestInterfaceImplementation* testInterface; | 9514 TestInterfaceImplementation* testInterface; |
9515 { | 9515 { |
9516 testInterface = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(),
info[0]); | 9516 testInterface = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(inf
o[0])); |
9517 } | 9517 } |
9518 impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface); | 9518 impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface); |
9519 } | 9519 } |
9520 | 9520 |
9521 static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::Functio
nCallbackInfo<v8::Value>& info) | 9521 static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::Functio
nCallbackInfo<v8::Value>& info) |
9522 { | 9522 { |
9523 ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRu
ntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate(
)); | 9523 ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRu
ntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate(
)); |
9524 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9524 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9525 int longArg; | 9525 int longArg; |
9526 { | 9526 { |
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9655 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("t
ypeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); | 9655 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("t
ypeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); |
9656 return; | 9656 return; |
9657 } | 9657 } |
9658 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9658 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9659 TestInterfaceEmpty* testInterfaceEmptyArg; | 9659 TestInterfaceEmpty* testInterfaceEmptyArg; |
9660 { | 9660 { |
9661 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], inf
o.GetIsolate())) { | 9661 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], inf
o.GetIsolate())) { |
9662 V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute(
"typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter
1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 9662 V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute(
"typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter
1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); |
9663 return; | 9663 return; |
9664 } | 9664 } |
9665 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 9665 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Obje
ct>::Cast(info[0])); |
9666 } | 9666 } |
9667 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt
yArg); | 9667 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt
yArg); |
9668 } | 9668 } |
9669 | 9669 |
9670 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9670 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
9671 { | 9671 { |
9672 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9672 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9673 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); | 9673 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); |
9674 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9674 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9675 } | 9675 } |
(...skipping 244 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9920 | 9920 |
9921 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) | 9921 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) |
9922 { | 9922 { |
9923 if (UNLIKELY(info.Length() < 1)) { | 9923 if (UNLIKELY(info.Length() < 1)) { |
9924 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("n
odeMethodWithNodeArgumentImplementedInPrivateScript", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); | 9924 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("n
odeMethodWithNodeArgumentImplementedInPrivateScript", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); |
9925 return; | 9925 return; |
9926 } | 9926 } |
9927 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9927 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9928 Node* value; | 9928 Node* value; |
9929 { | 9929 { |
9930 value = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]); | 9930 value = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
9931 } | 9931 } |
9932 RefPtrWillBeRawPtr<Node> result = nullptr; | 9932 RefPtrWillBeRawPtr<Node> result = nullptr; |
9933 if (!V8TestObject::PrivateScript::nodeMethodWithNodeArgumentImplementedInPri
vateScriptMethod(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()), i
mpl, value, &result)) | 9933 if (!V8TestObject::PrivateScript::nodeMethodWithNodeArgumentImplementedInPri
vateScriptMethod(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()), i
mpl, value, &result)) |
9934 return; | 9934 return; |
9935 v8SetReturnValue(info, result.release()); | 9935 v8SetReturnValue(info, result.release()); |
9936 } | 9936 } |
9937 | 9937 |
9938 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9938 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
9939 { | 9939 { |
9940 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9940 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9941 TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMe
thod(info); | 9941 TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMe
thod(info); |
9942 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9942 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9943 } | 9943 } |
9944 | 9944 |
9945 static void nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9945 static void nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) |
9946 { | 9946 { |
9947 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", info.Holder(), inf
o.GetIsolate()); | 9947 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", info.Holder(), inf
o.GetIsolate()); |
9948 if (UNLIKELY(info.Length() < 5)) { | 9948 if (UNLIKELY(info.Length() < 5)) { |
9949 setMinimumArityTypeError(exceptionState, 5, info.Length()); | 9949 setMinimumArityTypeError(exceptionState, 5, info.Length()); |
9950 exceptionState.throwIfNeeded(); | 9950 exceptionState.throwIfNeeded(); |
9951 return; | 9951 return; |
9952 } | 9952 } |
9953 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9953 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9954 Document* document; | 9954 Document* document; |
9955 Node* node; | 9955 Node* node; |
9956 int value1; | 9956 int value1; |
9957 double value2; | 9957 double value2; |
9958 V8StringResource<> string; | 9958 V8StringResource<> string; |
9959 { | 9959 { |
9960 document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]); | 9960 document = V8Document::toImpl(v8::Handle<v8::Object>::Cast(info[0])); |
9961 node = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]); | 9961 node = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[1])); |
9962 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value1, toInt16(info[2], exception
State), exceptionState); | 9962 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value1, toInt16(info[2], exception
State), exceptionState); |
9963 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value2, toDouble(info[3], exceptio
nState), exceptionState); | 9963 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value2, toDouble(info[3], exceptio
nState), exceptionState); |
9964 TOSTRING_VOID_INTERNAL(string, info[4]); | 9964 TOSTRING_VOID_INTERNAL(string, info[4]); |
9965 } | 9965 } |
9966 RefPtrWillBeRawPtr<Node> result = nullptr; | 9966 RefPtrWillBeRawPtr<Node> result = nullptr; |
9967 if (!V8TestObject::PrivateScript::nodeMethodWithVariousArgumentsImplementedI
nPrivateScriptMethod(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()
), impl, document, node, value1, value2, string, &result)) | 9967 if (!V8TestObject::PrivateScript::nodeMethodWithVariousArgumentsImplementedI
nPrivateScriptMethod(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()
), impl, document, node, value1, value2, string, &result)) |
9968 return; | 9968 return; |
9969 v8SetReturnValue(info, result.release()); | 9969 v8SetReturnValue(info, result.release()); |
9970 } | 9970 } |
9971 | 9971 |
(...skipping 742 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10714 | 10714 |
10715 ScriptState::Scope scope(scriptState); | 10715 ScriptState::Scope scope(scriptState); |
10716 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); | 10716 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); |
10717 | 10717 |
10718 v8::Handle<v8::Value> valueHandle = toV8(value, scriptState->context()->Glob
al(), scriptState->isolate()); | 10718 v8::Handle<v8::Value> valueHandle = toV8(value, scriptState->context()->Glob
al(), scriptState->isolate()); |
10719 v8::Handle<v8::Value> argv[] = { valueHandle }; | 10719 v8::Handle<v8::Value> argv[] = { valueHandle }; |
10720 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithNodeArgumentImplementedInPrivateScript", "TestObject", scriptState->context()
->Global(), scriptState->isolate()); | 10720 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithNodeArgumentImplementedInPrivateScript", "TestObject", scriptState->context()
->Global(), scriptState->isolate()); |
10721 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, scriptStateInUserScript, "TestObject", "nodeMethodWithNodeArgumentImplemented
InPrivateScript", holder, 1, argv); | 10721 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, scriptStateInUserScript, "TestObject", "nodeMethodWithNodeArgumentImplemented
InPrivateScript", holder, 1, argv); |
10722 if (v8Value.IsEmpty()) | 10722 if (v8Value.IsEmpty()) |
10723 return false; | 10723 return false; |
10724 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); | 10724 Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
10725 *result = cppValue; | 10725 *result = cppValue; |
10726 RELEASE_ASSERT(!exceptionState.hadException()); | 10726 RELEASE_ASSERT(!exceptionState.hadException()); |
10727 return true; | 10727 return true; |
10728 } | 10728 } |
10729 | 10729 |
10730 bool V8TestObject::PrivateScript::nodeMethodWithVariousArgumentsImplementedInPri
vateScriptMethod(LocalFrame* frame, TestObject* holderImpl, PassRefPtrWillBeRawP
tr<Document> document, PassRefPtrWillBeRawPtr<Node> node, int value1, double val
ue2, String string, RefPtrWillBeRawPtr<Node>* result) | 10730 bool V8TestObject::PrivateScript::nodeMethodWithVariousArgumentsImplementedInPri
vateScriptMethod(LocalFrame* frame, TestObject* holderImpl, PassRefPtrWillBeRawP
tr<Document> document, PassRefPtrWillBeRawPtr<Node> node, int value1, double val
ue2, String string, RefPtrWillBeRawPtr<Node>* result) |
10731 { | 10731 { |
10732 if (!frame) | 10732 if (!frame) |
10733 return false; | 10733 return false; |
10734 v8::HandleScope handleScope(toIsolate(frame)); | 10734 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 12 matching lines...) Expand all Loading... |
10747 v8::Handle<v8::Value> documentHandle = toV8(document, scriptState->context()
->Global(), scriptState->isolate()); | 10747 v8::Handle<v8::Value> documentHandle = toV8(document, scriptState->context()
->Global(), scriptState->isolate()); |
10748 v8::Handle<v8::Value> nodeHandle = toV8(node, scriptState->context()->Global
(), scriptState->isolate()); | 10748 v8::Handle<v8::Value> nodeHandle = toV8(node, scriptState->context()->Global
(), scriptState->isolate()); |
10749 v8::Handle<v8::Value> value1Handle = v8::Integer::New(scriptState->isolate()
, value1); | 10749 v8::Handle<v8::Value> value1Handle = v8::Integer::New(scriptState->isolate()
, value1); |
10750 v8::Handle<v8::Value> value2Handle = v8::Number::New(scriptState->isolate(),
value2); | 10750 v8::Handle<v8::Value> value2Handle = v8::Number::New(scriptState->isolate(),
value2); |
10751 v8::Handle<v8::Value> stringHandle = v8String(scriptState->isolate(), string
); | 10751 v8::Handle<v8::Value> stringHandle = v8String(scriptState->isolate(), string
); |
10752 v8::Handle<v8::Value> argv[] = { documentHandle, nodeHandle, value1Handle, v
alue2Handle, stringHandle }; | 10752 v8::Handle<v8::Value> argv[] = { documentHandle, nodeHandle, value1Handle, v
alue2Handle, stringHandle }; |
10753 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", scriptState->conte
xt()->Global(), scriptState->isolate()); | 10753 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", scriptState->conte
xt()->Global(), scriptState->isolate()); |
10754 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, scriptStateInUserScript, "TestObject", "nodeMethodWithVariousArgumentsImpleme
ntedInPrivateScript", holder, 5, argv); | 10754 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, scriptStateInUserScript, "TestObject", "nodeMethodWithVariousArgumentsImpleme
ntedInPrivateScript", holder, 5, argv); |
10755 if (v8Value.IsEmpty()) | 10755 if (v8Value.IsEmpty()) |
10756 return false; | 10756 return false; |
10757 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); | 10757 Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
10758 *result = cppValue; | 10758 *result = cppValue; |
10759 RELEASE_ASSERT(!exceptionState.hadException()); | 10759 RELEASE_ASSERT(!exceptionState.hadException()); |
10760 return true; | 10760 return true; |
10761 } | 10761 } |
10762 | 10762 |
10763 bool V8TestObject::PrivateScript::methodForPrivateScriptOnlyMethod(LocalFrame* f
rame, TestObject* holderImpl, int value1, int value2, int* result) | 10763 bool V8TestObject::PrivateScript::methodForPrivateScriptOnlyMethod(LocalFrame* f
rame, TestObject* holderImpl, int value1, int value2, int* result) |
10764 { | 10764 { |
10765 if (!frame) | 10765 if (!frame) |
10766 return false; | 10766 return false; |
10767 v8::HandleScope handleScope(toIsolate(frame)); | 10767 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10927 if (!scriptState->executionContext()) | 10927 if (!scriptState->executionContext()) |
10928 return false; | 10928 return false; |
10929 | 10929 |
10930 ScriptState::Scope scope(scriptState); | 10930 ScriptState::Scope scope(scriptState); |
10931 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); | 10931 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); |
10932 | 10932 |
10933 ExceptionState exceptionState(ExceptionState::GetterContext, "nodeAttribute"
, "TestObject", scriptState->context()->Global(), scriptState->isolate()); | 10933 ExceptionState exceptionState(ExceptionState::GetterContext, "nodeAttribute"
, "TestObject", scriptState->context()->Global(), scriptState->isolate()); |
10934 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMAttributeGetter(s
criptState, scriptStateInUserScript, "TestObject", "nodeAttribute", holder); | 10934 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMAttributeGetter(s
criptState, scriptStateInUserScript, "TestObject", "nodeAttribute", holder); |
10935 if (v8Value.IsEmpty()) | 10935 if (v8Value.IsEmpty()) |
10936 return false; | 10936 return false; |
10937 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); | 10937 Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value)); |
10938 RELEASE_ASSERT(!exceptionState.hadException()); | 10938 RELEASE_ASSERT(!exceptionState.hadException()); |
10939 *result = cppValue; | 10939 *result = cppValue; |
10940 return true; | 10940 return true; |
10941 } | 10941 } |
10942 | 10942 |
10943 bool V8TestObject::PrivateScript::nodeAttributeAttributeSetter(LocalFrame* frame
, TestObject* holderImpl, PassRefPtrWillBeRawPtr<Node> cppValue) | 10943 bool V8TestObject::PrivateScript::nodeAttributeAttributeSetter(LocalFrame* frame
, TestObject* holderImpl, PassRefPtrWillBeRawPtr<Node> cppValue) |
10944 { | 10944 { |
10945 if (!frame) | 10945 if (!frame) |
10946 return false; | 10946 return false; |
10947 v8::HandleScope handleScope(toIsolate(frame)); | 10947 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11051 return false; | 11051 return false; |
11052 | 11052 |
11053 ScriptState::Scope scope(scriptState); | 11053 ScriptState::Scope scope(scriptState); |
11054 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); | 11054 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); |
11055 | 11055 |
11056 ExceptionState exceptionState(ExceptionState::SetterContext, "enumForPrivate
Script", "TestObject", scriptState->context()->Global(), scriptState->isolate())
; | 11056 ExceptionState exceptionState(ExceptionState::SetterContext, "enumForPrivate
Script", "TestObject", scriptState->context()->Global(), scriptState->isolate())
; |
11057 return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateIn
UserScript, "TestObject", "enumForPrivateScript", holder, v8String(scriptState->
isolate(), cppValue)); | 11057 return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateIn
UserScript, "TestObject", "enumForPrivateScript", holder, v8String(scriptState->
isolate(), cppValue)); |
11058 } | 11058 } |
11059 | 11059 |
11060 } // namespace blink | 11060 } // namespace blink |
OLD | NEW |