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 306 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
317 { | 317 { |
318 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 318 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
319 TestObjectV8Internal::booleanAttributeAttributeGetter(info); | 319 TestObjectV8Internal::booleanAttributeAttributeGetter(info); |
320 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 320 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
321 } | 321 } |
322 | 322 |
323 static void booleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) | 323 static void booleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) |
324 { | 324 { |
325 v8::Handle<v8::Object> holder = info.Holder(); | 325 v8::Handle<v8::Object> holder = info.Holder(); |
326 TestObject* impl = V8TestObject::toImpl(holder); | 326 TestObject* impl = V8TestObject::toImpl(holder); |
327 TONATIVE_VOID(bool, cppValue, v8Value->BooleanValue()); | 327 bool cppValue = v8Value->BooleanValue(); |
328 impl->setBooleanAttribute(cppValue); | 328 impl->setBooleanAttribute(cppValue); |
329 } | 329 } |
330 | 330 |
331 static void booleanAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 331 static void booleanAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
332 { | 332 { |
333 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 333 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
334 TestObjectV8Internal::booleanAttributeAttributeSetter(v8Value, info); | 334 TestObjectV8Internal::booleanAttributeAttributeSetter(v8Value, info); |
335 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 335 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
336 } | 336 } |
337 | 337 |
(...skipping 368 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 { | 706 { |
707 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 707 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
708 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeGetter(info); | 708 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeGetter(info); |
709 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 709 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
710 } | 710 } |
711 | 711 |
712 static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) | 712 static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) |
713 { | 713 { |
714 v8::Handle<v8::Object> holder = info.Holder(); | 714 v8::Handle<v8::Object> holder = info.Holder(); |
715 TestObject* impl = V8TestObject::toImpl(holder); | 715 TestObject* impl = V8TestObject::toImpl(holder); |
716 TONATIVE_VOID(TestInterfaceEmpty*, cppValue, V8TestInterfaceEmpty::toImplWit
hTypeCheck(info.GetIsolate(), v8Value)); | 716 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(inf
o.GetIsolate(), v8Value); |
717 impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue)); | 717 impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue)); |
718 } | 718 } |
719 | 719 |
720 static void testInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 720 static void testInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
721 { | 721 { |
722 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 722 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
723 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, in
fo); | 723 TestObjectV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, in
fo); |
724 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 724 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
725 } | 725 } |
726 | 726 |
727 static void testObjectAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 727 static void testObjectAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
728 { | 728 { |
729 v8::Handle<v8::Object> holder = info.Holder(); | 729 v8::Handle<v8::Object> holder = info.Holder(); |
730 TestObject* impl = V8TestObject::toImpl(holder); | 730 TestObject* impl = V8TestObject::toImpl(holder); |
731 v8SetReturnValueFast(info, WTF::getPtr(impl->testObjectAttribute()), impl); | 731 v8SetReturnValueFast(info, WTF::getPtr(impl->testObjectAttribute()), impl); |
732 } | 732 } |
733 | 733 |
734 static void testObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 734 static void testObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
735 { | 735 { |
736 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 736 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
737 TestObjectV8Internal::testObjectAttributeAttributeGetter(info); | 737 TestObjectV8Internal::testObjectAttributeAttributeGetter(info); |
738 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 738 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
739 } | 739 } |
740 | 740 |
741 static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 741 static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
742 { | 742 { |
743 v8::Handle<v8::Object> holder = info.Holder(); | 743 v8::Handle<v8::Object> holder = info.Holder(); |
744 TestObject* impl = V8TestObject::toImpl(holder); | 744 TestObject* impl = V8TestObject::toImpl(holder); |
745 TONATIVE_VOID(TestObject*, cppValue, V8TestObject::toImplWithTypeCheck(info.
GetIsolate(), v8Value)); | 745 TestObject* cppValue = V8TestObject::toImplWithTypeCheck(info.GetIsolate(),
v8Value); |
746 impl->setTestObjectAttribute(WTF::getPtr(cppValue)); | 746 impl->setTestObjectAttribute(WTF::getPtr(cppValue)); |
747 } | 747 } |
748 | 748 |
749 static void testObjectAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 749 static void testObjectAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
750 { | 750 { |
751 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 751 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
752 TestObjectV8Internal::testObjectAttributeAttributeSetter(v8Value, info); | 752 TestObjectV8Internal::testObjectAttributeAttributeSetter(v8Value, info); |
753 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 753 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
754 } | 754 } |
755 | 755 |
756 static void voidCallbackFunctionAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) | 756 static void voidCallbackFunctionAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) |
757 { | 757 { |
758 v8::Handle<v8::Object> holder = info.Holder(); | 758 v8::Handle<v8::Object> holder = info.Holder(); |
759 TestObject* impl = V8TestObject::toImpl(holder); | 759 TestObject* impl = V8TestObject::toImpl(holder); |
760 v8SetReturnValue(info, impl->voidCallbackFunctionAttribute().v8Value()); | 760 v8SetReturnValue(info, impl->voidCallbackFunctionAttribute().v8Value()); |
761 } | 761 } |
762 | 762 |
763 static void voidCallbackFunctionAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) | 763 static void voidCallbackFunctionAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) |
764 { | 764 { |
765 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 765 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
766 TestObjectV8Internal::voidCallbackFunctionAttributeAttributeGetter(info); | 766 TestObjectV8Internal::voidCallbackFunctionAttributeAttributeGetter(info); |
767 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 767 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
768 } | 768 } |
769 | 769 |
770 static void voidCallbackFunctionAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) | 770 static void voidCallbackFunctionAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) |
771 { | 771 { |
772 v8::Handle<v8::Object> holder = info.Holder(); | 772 v8::Handle<v8::Object> holder = info.Holder(); |
773 TestObject* impl = V8TestObject::toImpl(holder); | 773 TestObject* impl = V8TestObject::toImpl(holder); |
774 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 774 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
775 impl->setVoidCallbackFunctionAttribute(cppValue); | 775 impl->setVoidCallbackFunctionAttribute(cppValue); |
776 } | 776 } |
777 | 777 |
778 static void voidCallbackFunctionAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) | 778 static void voidCallbackFunctionAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) |
779 { | 779 { |
780 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 780 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
781 TestObjectV8Internal::voidCallbackFunctionAttributeAttributeSetter(v8Value,
info); | 781 TestObjectV8Internal::voidCallbackFunctionAttributeAttributeSetter(v8Value,
info); |
782 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 782 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
783 } | 783 } |
784 | 784 |
785 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetter(const v8::
PropertyCallbackInfo<v8::Value>& info) | 785 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetter(const v8::
PropertyCallbackInfo<v8::Value>& info) |
786 { | 786 { |
787 v8::Handle<v8::Object> holder = info.Holder(); | 787 v8::Handle<v8::Object> holder = info.Holder(); |
788 TestObject* impl = V8TestObject::toImpl(holder); | 788 TestObject* impl = V8TestObject::toImpl(holder); |
789 v8SetReturnValue(info, impl->anyCallbackFunctionOptionalAnyArgAttribute().v8
Value()); | 789 v8SetReturnValue(info, impl->anyCallbackFunctionOptionalAnyArgAttribute().v8
Value()); |
790 } | 790 } |
791 | 791 |
792 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetterCallback(v8
::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 792 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetterCallback(v8
::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
793 { | 793 { |
794 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 794 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
795 TestObjectV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeGet
ter(info); | 795 TestObjectV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeGet
ter(info); |
796 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 796 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
797 } | 797 } |
798 | 798 |
799 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 799 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
800 { | 800 { |
801 v8::Handle<v8::Object> holder = info.Holder(); | 801 v8::Handle<v8::Object> holder = info.Holder(); |
802 TestObject* impl = V8TestObject::toImpl(holder); | 802 TestObject* impl = V8TestObject::toImpl(holder); |
803 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 803 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
804 impl->setAnyCallbackFunctionOptionalAnyArgAttribute(cppValue); | 804 impl->setAnyCallbackFunctionOptionalAnyArgAttribute(cppValue); |
805 } | 805 } |
806 | 806 |
807 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) | 807 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) |
808 { | 808 { |
809 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 809 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
810 TestObjectV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeSet
ter(v8Value, info); | 810 TestObjectV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeSet
ter(v8Value, info); |
811 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 811 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
812 } | 812 } |
813 | 813 |
(...skipping 186 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1000 { | 1000 { |
1001 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1001 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1002 TestObjectV8Internal::anyAttributeAttributeGetter(info); | 1002 TestObjectV8Internal::anyAttributeAttributeGetter(info); |
1003 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1003 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1004 } | 1004 } |
1005 | 1005 |
1006 static void anyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::
PropertyCallbackInfo<void>& info) | 1006 static void anyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::
PropertyCallbackInfo<void>& info) |
1007 { | 1007 { |
1008 v8::Handle<v8::Object> holder = info.Holder(); | 1008 v8::Handle<v8::Object> holder = info.Holder(); |
1009 TestObject* impl = V8TestObject::toImpl(holder); | 1009 TestObject* impl = V8TestObject::toImpl(holder); |
1010 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 1010 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
1011 impl->setAnyAttribute(cppValue); | 1011 impl->setAnyAttribute(cppValue); |
1012 } | 1012 } |
1013 | 1013 |
1014 static void anyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1014 static void anyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1015 { | 1015 { |
1016 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1016 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1017 TestObjectV8Internal::anyAttributeAttributeSetter(v8Value, info); | 1017 TestObjectV8Internal::anyAttributeAttributeSetter(v8Value, info); |
1018 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1018 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1019 } | 1019 } |
1020 | 1020 |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1058 { | 1058 { |
1059 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1059 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1060 TestObjectV8Internal::windowAttributeAttributeGetter(info); | 1060 TestObjectV8Internal::windowAttributeAttributeGetter(info); |
1061 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1061 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1062 } | 1062 } |
1063 | 1063 |
1064 static void windowAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v
8::PropertyCallbackInfo<void>& info) | 1064 static void windowAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v
8::PropertyCallbackInfo<void>& info) |
1065 { | 1065 { |
1066 v8::Handle<v8::Object> holder = info.Holder(); | 1066 v8::Handle<v8::Object> holder = info.Holder(); |
1067 TestObject* impl = V8TestObject::toImpl(holder); | 1067 TestObject* impl = V8TestObject::toImpl(holder); |
1068 TONATIVE_VOID(LocalDOMWindow*, cppValue, toDOMWindow(v8Value, info.GetIsolat
e())); | 1068 LocalDOMWindow* cppValue = toDOMWindow(v8Value, info.GetIsolate()); |
1069 impl->setWindowAttribute(WTF::getPtr(cppValue)); | 1069 impl->setWindowAttribute(WTF::getPtr(cppValue)); |
1070 } | 1070 } |
1071 | 1071 |
1072 static void windowAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Lo
cal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1072 static void windowAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Lo
cal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1073 { | 1073 { |
1074 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1074 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1075 TestObjectV8Internal::windowAttributeAttributeSetter(v8Value, info); | 1075 TestObjectV8Internal::windowAttributeAttributeSetter(v8Value, info); |
1076 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1076 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1077 } | 1077 } |
1078 | 1078 |
1079 static void documentAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::
Value>& info) | 1079 static void documentAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::
Value>& info) |
1080 { | 1080 { |
1081 v8::Handle<v8::Object> holder = info.Holder(); | 1081 v8::Handle<v8::Object> holder = info.Holder(); |
1082 TestObject* impl = V8TestObject::toImpl(holder); | 1082 TestObject* impl = V8TestObject::toImpl(holder); |
1083 v8SetReturnValueFast(info, WTF::getPtr(impl->documentAttribute()), impl); | 1083 v8SetReturnValueFast(info, WTF::getPtr(impl->documentAttribute()), impl); |
1084 } | 1084 } |
1085 | 1085 |
1086 static void documentAttributeAttributeGetterCallback(v8::Local<v8::String>, cons
t v8::PropertyCallbackInfo<v8::Value>& info) | 1086 static void documentAttributeAttributeGetterCallback(v8::Local<v8::String>, cons
t v8::PropertyCallbackInfo<v8::Value>& info) |
1087 { | 1087 { |
1088 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1088 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1089 TestObjectV8Internal::documentAttributeAttributeGetter(info); | 1089 TestObjectV8Internal::documentAttributeAttributeGetter(info); |
1090 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1090 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1091 } | 1091 } |
1092 | 1092 |
1093 static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) | 1093 static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) |
1094 { | 1094 { |
1095 v8::Handle<v8::Object> holder = info.Holder(); | 1095 v8::Handle<v8::Object> holder = info.Holder(); |
1096 TestObject* impl = V8TestObject::toImpl(holder); | 1096 TestObject* impl = V8TestObject::toImpl(holder); |
1097 TONATIVE_VOID(Document*, cppValue, V8Document::toImplWithTypeCheck(info.GetI
solate(), v8Value)); | 1097 Document* cppValue = V8Document::toImplWithTypeCheck(info.GetIsolate(), v8Va
lue); |
1098 impl->setDocumentAttribute(WTF::getPtr(cppValue)); | 1098 impl->setDocumentAttribute(WTF::getPtr(cppValue)); |
1099 } | 1099 } |
1100 | 1100 |
1101 static void documentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1101 static void documentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1102 { | 1102 { |
1103 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1103 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1104 TestObjectV8Internal::documentAttributeAttributeSetter(v8Value, info); | 1104 TestObjectV8Internal::documentAttributeAttributeSetter(v8Value, info); |
1105 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1105 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1106 } | 1106 } |
1107 | 1107 |
1108 static void documentFragmentAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) | 1108 static void documentFragmentAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) |
1109 { | 1109 { |
1110 v8::Handle<v8::Object> holder = info.Holder(); | 1110 v8::Handle<v8::Object> holder = info.Holder(); |
1111 TestObject* impl = V8TestObject::toImpl(holder); | 1111 TestObject* impl = V8TestObject::toImpl(holder); |
1112 v8SetReturnValueFast(info, WTF::getPtr(impl->documentFragmentAttribute()), i
mpl); | 1112 v8SetReturnValueFast(info, WTF::getPtr(impl->documentFragmentAttribute()), i
mpl); |
1113 } | 1113 } |
1114 | 1114 |
1115 static void documentFragmentAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1115 static void documentFragmentAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1116 { | 1116 { |
1117 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1117 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1118 TestObjectV8Internal::documentFragmentAttributeAttributeGetter(info); | 1118 TestObjectV8Internal::documentFragmentAttributeAttributeGetter(info); |
1119 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1119 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1120 } | 1120 } |
1121 | 1121 |
1122 static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Valu
e, const v8::PropertyCallbackInfo<void>& info) | 1122 static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Valu
e, const v8::PropertyCallbackInfo<void>& info) |
1123 { | 1123 { |
1124 v8::Handle<v8::Object> holder = info.Holder(); | 1124 v8::Handle<v8::Object> holder = info.Holder(); |
1125 TestObject* impl = V8TestObject::toImpl(holder); | 1125 TestObject* impl = V8TestObject::toImpl(holder); |
1126 TONATIVE_VOID(DocumentFragment*, cppValue, V8DocumentFragment::toImplWithTyp
eCheck(info.GetIsolate(), v8Value)); | 1126 DocumentFragment* cppValue = V8DocumentFragment::toImplWithTypeCheck(info.Ge
tIsolate(), v8Value); |
1127 impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue)); | 1127 impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue)); |
1128 } | 1128 } |
1129 | 1129 |
1130 static void documentFragmentAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1130 static void documentFragmentAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1131 { | 1131 { |
1132 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1132 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1133 TestObjectV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info
); | 1133 TestObjectV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info
); |
1134 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1134 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1135 } | 1135 } |
1136 | 1136 |
1137 static void documentTypeAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) | 1137 static void documentTypeAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) |
1138 { | 1138 { |
1139 v8::Handle<v8::Object> holder = info.Holder(); | 1139 v8::Handle<v8::Object> holder = info.Holder(); |
1140 TestObject* impl = V8TestObject::toImpl(holder); | 1140 TestObject* impl = V8TestObject::toImpl(holder); |
1141 v8SetReturnValueFast(info, WTF::getPtr(impl->documentTypeAttribute()), impl)
; | 1141 v8SetReturnValueFast(info, WTF::getPtr(impl->documentTypeAttribute()), impl)
; |
1142 } | 1142 } |
1143 | 1143 |
1144 static void documentTypeAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 1144 static void documentTypeAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
1145 { | 1145 { |
1146 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1146 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1147 TestObjectV8Internal::documentTypeAttributeAttributeGetter(info); | 1147 TestObjectV8Internal::documentTypeAttributeAttributeGetter(info); |
1148 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1148 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1149 } | 1149 } |
1150 | 1150 |
1151 static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) | 1151 static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) |
1152 { | 1152 { |
1153 v8::Handle<v8::Object> holder = info.Holder(); | 1153 v8::Handle<v8::Object> holder = info.Holder(); |
1154 TestObject* impl = V8TestObject::toImpl(holder); | 1154 TestObject* impl = V8TestObject::toImpl(holder); |
1155 TONATIVE_VOID(DocumentType*, cppValue, V8DocumentType::toImplWithTypeCheck(i
nfo.GetIsolate(), v8Value)); | 1155 DocumentType* cppValue = V8DocumentType::toImplWithTypeCheck(info.GetIsolate
(), v8Value); |
1156 impl->setDocumentTypeAttribute(WTF::getPtr(cppValue)); | 1156 impl->setDocumentTypeAttribute(WTF::getPtr(cppValue)); |
1157 } | 1157 } |
1158 | 1158 |
1159 static void documentTypeAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1159 static void documentTypeAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1160 { | 1160 { |
1161 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1161 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1162 TestObjectV8Internal::documentTypeAttributeAttributeSetter(v8Value, info); | 1162 TestObjectV8Internal::documentTypeAttributeAttributeSetter(v8Value, info); |
1163 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1163 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1164 } | 1164 } |
1165 | 1165 |
1166 static void elementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::V
alue>& info) | 1166 static void elementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::V
alue>& info) |
1167 { | 1167 { |
1168 v8::Handle<v8::Object> holder = info.Holder(); | 1168 v8::Handle<v8::Object> holder = info.Holder(); |
1169 TestObject* impl = V8TestObject::toImpl(holder); | 1169 TestObject* impl = V8TestObject::toImpl(holder); |
1170 v8SetReturnValueFast(info, WTF::getPtr(impl->elementAttribute()), impl); | 1170 v8SetReturnValueFast(info, WTF::getPtr(impl->elementAttribute()), impl); |
1171 } | 1171 } |
1172 | 1172 |
1173 static void elementAttributeAttributeGetterCallback(v8::Local<v8::String>, const
v8::PropertyCallbackInfo<v8::Value>& info) | 1173 static void elementAttributeAttributeGetterCallback(v8::Local<v8::String>, const
v8::PropertyCallbackInfo<v8::Value>& info) |
1174 { | 1174 { |
1175 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1175 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1176 TestObjectV8Internal::elementAttributeAttributeGetter(info); | 1176 TestObjectV8Internal::elementAttributeAttributeGetter(info); |
1177 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1177 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1178 } | 1178 } |
1179 | 1179 |
1180 static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) | 1180 static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const
v8::PropertyCallbackInfo<void>& info) |
1181 { | 1181 { |
1182 v8::Handle<v8::Object> holder = info.Holder(); | 1182 v8::Handle<v8::Object> holder = info.Holder(); |
1183 TestObject* impl = V8TestObject::toImpl(holder); | 1183 TestObject* impl = V8TestObject::toImpl(holder); |
1184 TONATIVE_VOID(Element*, cppValue, V8Element::toImplWithTypeCheck(info.GetIso
late(), v8Value)); | 1184 Element* cppValue = V8Element::toImplWithTypeCheck(info.GetIsolate(), v8Valu
e); |
1185 impl->setElementAttribute(WTF::getPtr(cppValue)); | 1185 impl->setElementAttribute(WTF::getPtr(cppValue)); |
1186 } | 1186 } |
1187 | 1187 |
1188 static void elementAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1188 static void elementAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::L
ocal<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1189 { | 1189 { |
1190 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1190 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1191 TestObjectV8Internal::elementAttributeAttributeSetter(v8Value, info); | 1191 TestObjectV8Internal::elementAttributeAttributeSetter(v8Value, info); |
1192 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1192 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1193 } | 1193 } |
1194 | 1194 |
1195 static void nodeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Valu
e>& info) | 1195 static void nodeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Valu
e>& info) |
1196 { | 1196 { |
1197 v8::Handle<v8::Object> holder = info.Holder(); | 1197 v8::Handle<v8::Object> holder = info.Holder(); |
1198 TestObject* impl = V8TestObject::toImpl(holder); | 1198 TestObject* impl = V8TestObject::toImpl(holder); |
1199 v8SetReturnValueFast(info, WTF::getPtr(impl->nodeAttribute()), impl); | 1199 v8SetReturnValueFast(info, WTF::getPtr(impl->nodeAttribute()), impl); |
1200 } | 1200 } |
1201 | 1201 |
1202 static void nodeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) | 1202 static void nodeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) |
1203 { | 1203 { |
1204 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1204 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1205 TestObjectV8Internal::nodeAttributeAttributeGetter(info); | 1205 TestObjectV8Internal::nodeAttributeAttributeGetter(info); |
1206 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1206 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1207 } | 1207 } |
1208 | 1208 |
1209 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) | 1209 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) |
1210 { | 1210 { |
1211 v8::Handle<v8::Object> holder = info.Holder(); | 1211 v8::Handle<v8::Object> holder = info.Holder(); |
1212 TestObject* impl = V8TestObject::toImpl(holder); | 1212 TestObject* impl = V8TestObject::toImpl(holder); |
1213 TONATIVE_VOID(Node*, cppValue, V8Node::toImplWithTypeCheck(info.GetIsolate()
, v8Value)); | 1213 Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value); |
1214 impl->setNodeAttribute(WTF::getPtr(cppValue)); | 1214 impl->setNodeAttribute(WTF::getPtr(cppValue)); |
1215 } | 1215 } |
1216 | 1216 |
1217 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1217 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1218 { | 1218 { |
1219 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1219 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1220 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); | 1220 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); |
1221 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1221 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1222 } | 1222 } |
1223 | 1223 |
1224 static void shadowRootAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 1224 static void shadowRootAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
1225 { | 1225 { |
1226 v8::Handle<v8::Object> holder = info.Holder(); | 1226 v8::Handle<v8::Object> holder = info.Holder(); |
1227 TestObject* impl = V8TestObject::toImpl(holder); | 1227 TestObject* impl = V8TestObject::toImpl(holder); |
1228 v8SetReturnValueFast(info, WTF::getPtr(impl->shadowRootAttribute()), impl); | 1228 v8SetReturnValueFast(info, WTF::getPtr(impl->shadowRootAttribute()), impl); |
1229 } | 1229 } |
1230 | 1230 |
1231 static void shadowRootAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 1231 static void shadowRootAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
1232 { | 1232 { |
1233 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1233 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1234 TestObjectV8Internal::shadowRootAttributeAttributeGetter(info); | 1234 TestObjectV8Internal::shadowRootAttributeAttributeGetter(info); |
1235 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1235 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1236 } | 1236 } |
1237 | 1237 |
1238 static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 1238 static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
1239 { | 1239 { |
1240 v8::Handle<v8::Object> holder = info.Holder(); | 1240 v8::Handle<v8::Object> holder = info.Holder(); |
1241 TestObject* impl = V8TestObject::toImpl(holder); | 1241 TestObject* impl = V8TestObject::toImpl(holder); |
1242 TONATIVE_VOID(ShadowRoot*, cppValue, V8ShadowRoot::toImplWithTypeCheck(info.
GetIsolate(), v8Value)); | 1242 ShadowRoot* cppValue = V8ShadowRoot::toImplWithTypeCheck(info.GetIsolate(),
v8Value); |
1243 impl->setShadowRootAttribute(WTF::getPtr(cppValue)); | 1243 impl->setShadowRootAttribute(WTF::getPtr(cppValue)); |
1244 } | 1244 } |
1245 | 1245 |
1246 static void shadowRootAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1246 static void shadowRootAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1247 { | 1247 { |
1248 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1248 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1249 TestObjectV8Internal::shadowRootAttributeAttributeSetter(v8Value, info); | 1249 TestObjectV8Internal::shadowRootAttributeAttributeSetter(v8Value, info); |
1250 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1250 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1251 } | 1251 } |
1252 | 1252 |
1253 static void arrayBufferAttributeAttributeGetter(const v8::PropertyCallbackInfo<v
8::Value>& info) | 1253 static void arrayBufferAttributeAttributeGetter(const v8::PropertyCallbackInfo<v
8::Value>& info) |
1254 { | 1254 { |
1255 v8::Handle<v8::Object> holder = info.Holder(); | 1255 v8::Handle<v8::Object> holder = info.Holder(); |
1256 TestObject* impl = V8TestObject::toImpl(holder); | 1256 TestObject* impl = V8TestObject::toImpl(holder); |
1257 v8SetReturnValueFast(info, WTF::getPtr(impl->arrayBufferAttribute()), impl); | 1257 v8SetReturnValueFast(info, WTF::getPtr(impl->arrayBufferAttribute()), impl); |
1258 } | 1258 } |
1259 | 1259 |
1260 static void arrayBufferAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) | 1260 static void arrayBufferAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) |
1261 { | 1261 { |
1262 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1262 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1263 TestObjectV8Internal::arrayBufferAttributeAttributeGetter(info); | 1263 TestObjectV8Internal::arrayBufferAttributeAttributeGetter(info); |
1264 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1264 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1265 } | 1265 } |
1266 | 1266 |
1267 static void arrayBufferAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) | 1267 static void arrayBufferAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) |
1268 { | 1268 { |
1269 v8::Handle<v8::Object> holder = info.Holder(); | 1269 v8::Handle<v8::Object> holder = info.Holder(); |
1270 TestObject* impl = V8TestObject::toImpl(holder); | 1270 TestObject* impl = V8TestObject::toImpl(holder); |
1271 TONATIVE_VOID(ArrayBuffer*, cppValue, v8Value->IsArrayBuffer() ? V8ArrayBuff
er::toImpl(v8::Handle<v8::ArrayBuffer>::Cast(v8Value)) : 0); | 1271 ArrayBuffer* cppValue = v8Value->IsArrayBuffer() ? V8ArrayBuffer::toImpl(v8:
:Handle<v8::ArrayBuffer>::Cast(v8Value)) : 0; |
1272 impl->setArrayBufferAttribute(WTF::getPtr(cppValue)); | 1272 impl->setArrayBufferAttribute(WTF::getPtr(cppValue)); |
1273 } | 1273 } |
1274 | 1274 |
1275 static void arrayBufferAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1275 static void arrayBufferAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1276 { | 1276 { |
1277 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1277 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1278 TestObjectV8Internal::arrayBufferAttributeAttributeSetter(v8Value, info); | 1278 TestObjectV8Internal::arrayBufferAttributeAttributeSetter(v8Value, info); |
1279 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1279 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1280 } | 1280 } |
1281 | 1281 |
1282 static void float32ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) | 1282 static void float32ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) |
1283 { | 1283 { |
1284 v8::Handle<v8::Object> holder = info.Holder(); | 1284 v8::Handle<v8::Object> holder = info.Holder(); |
1285 TestObject* impl = V8TestObject::toImpl(holder); | 1285 TestObject* impl = V8TestObject::toImpl(holder); |
1286 v8SetReturnValueFast(info, WTF::getPtr(impl->float32ArrayAttribute()), impl)
; | 1286 v8SetReturnValueFast(info, WTF::getPtr(impl->float32ArrayAttribute()), impl)
; |
1287 } | 1287 } |
1288 | 1288 |
1289 static void float32ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 1289 static void float32ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
1290 { | 1290 { |
1291 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1291 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1292 TestObjectV8Internal::float32ArrayAttributeAttributeGetter(info); | 1292 TestObjectV8Internal::float32ArrayAttributeAttributeGetter(info); |
1293 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1293 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1294 } | 1294 } |
1295 | 1295 |
1296 static void float32ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) | 1296 static void float32ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c
onst v8::PropertyCallbackInfo<void>& info) |
1297 { | 1297 { |
1298 v8::Handle<v8::Object> holder = info.Holder(); | 1298 v8::Handle<v8::Object> holder = info.Holder(); |
1299 TestObject* impl = V8TestObject::toImpl(holder); | 1299 TestObject* impl = V8TestObject::toImpl(holder); |
1300 TONATIVE_VOID(Float32Array*, cppValue, v8Value->IsFloat32Array() ? V8Float32
Array::toImpl(v8::Handle<v8::Float32Array>::Cast(v8Value)) : 0); | 1300 Float32Array* cppValue = v8Value->IsFloat32Array() ? V8Float32Array::toImpl(
v8::Handle<v8::Float32Array>::Cast(v8Value)) : 0; |
1301 impl->setFloat32ArrayAttribute(WTF::getPtr(cppValue)); | 1301 impl->setFloat32ArrayAttribute(WTF::getPtr(cppValue)); |
1302 } | 1302 } |
1303 | 1303 |
1304 static void float32ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1304 static void float32ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1305 { | 1305 { |
1306 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1306 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1307 TestObjectV8Internal::float32ArrayAttributeAttributeSetter(v8Value, info); | 1307 TestObjectV8Internal::float32ArrayAttributeAttributeSetter(v8Value, info); |
1308 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1308 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1309 } | 1309 } |
1310 | 1310 |
1311 static void uint8ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 1311 static void uint8ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
1312 { | 1312 { |
1313 v8::Handle<v8::Object> holder = info.Holder(); | 1313 v8::Handle<v8::Object> holder = info.Holder(); |
1314 TestObject* impl = V8TestObject::toImpl(holder); | 1314 TestObject* impl = V8TestObject::toImpl(holder); |
1315 v8SetReturnValueFast(info, WTF::getPtr(impl->uint8ArrayAttribute()), impl); | 1315 v8SetReturnValueFast(info, WTF::getPtr(impl->uint8ArrayAttribute()), impl); |
1316 } | 1316 } |
1317 | 1317 |
1318 static void uint8ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 1318 static void uint8ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
1319 { | 1319 { |
1320 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1320 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1321 TestObjectV8Internal::uint8ArrayAttributeAttributeGetter(info); | 1321 TestObjectV8Internal::uint8ArrayAttributeAttributeGetter(info); |
1322 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1322 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1323 } | 1323 } |
1324 | 1324 |
1325 static void uint8ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 1325 static void uint8ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
1326 { | 1326 { |
1327 v8::Handle<v8::Object> holder = info.Holder(); | 1327 v8::Handle<v8::Object> holder = info.Holder(); |
1328 TestObject* impl = V8TestObject::toImpl(holder); | 1328 TestObject* impl = V8TestObject::toImpl(holder); |
1329 TONATIVE_VOID(Uint8Array*, cppValue, v8Value->IsUint8Array() ? V8Uint8Array:
:toImpl(v8::Handle<v8::Uint8Array>::Cast(v8Value)) : 0); | 1329 Uint8Array* cppValue = v8Value->IsUint8Array() ? V8Uint8Array::toImpl(v8::Ha
ndle<v8::Uint8Array>::Cast(v8Value)) : 0; |
1330 impl->setUint8ArrayAttribute(WTF::getPtr(cppValue)); | 1330 impl->setUint8ArrayAttribute(WTF::getPtr(cppValue)); |
1331 } | 1331 } |
1332 | 1332 |
1333 static void uint8ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1333 static void uint8ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1334 { | 1334 { |
1335 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1335 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1336 TestObjectV8Internal::uint8ArrayAttributeAttributeSetter(v8Value, info); | 1336 TestObjectV8Internal::uint8ArrayAttributeAttributeSetter(v8Value, info); |
1337 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1337 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1338 } | 1338 } |
1339 | 1339 |
(...skipping 244 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1584 { | 1584 { |
1585 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1585 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1586 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeGetter(info); | 1586 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeGetter(info); |
1587 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1587 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1588 } | 1588 } |
1589 | 1589 |
1590 static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8V
alue, const v8::PropertyCallbackInfo<void>& info) | 1590 static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8V
alue, const v8::PropertyCallbackInfo<void>& info) |
1591 { | 1591 { |
1592 v8::Handle<v8::Object> holder = info.Holder(); | 1592 v8::Handle<v8::Object> holder = info.Holder(); |
1593 TestObject* impl = V8TestObject::toImpl(holder); | 1593 TestObject* impl = V8TestObject::toImpl(holder); |
1594 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 1594 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
1595 impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue)); | 1595 impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue)); |
1596 } | 1596 } |
1597 | 1597 |
1598 static void testInterfaceOrNullAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1598 static void testInterfaceOrNullAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1599 { | 1599 { |
1600 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1600 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1601 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, i
nfo); | 1601 TestObjectV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, i
nfo); |
1602 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1602 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1603 } | 1603 } |
1604 | 1604 |
(...skipping 239 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1844 { | 1844 { |
1845 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1845 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1846 TestObjectV8Internal::cachedAttributeAnyAttributeAttributeGetter(info); | 1846 TestObjectV8Internal::cachedAttributeAnyAttributeAttributeGetter(info); |
1847 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1847 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1848 } | 1848 } |
1849 | 1849 |
1850 static void cachedAttributeAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) | 1850 static void cachedAttributeAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Va
lue, const v8::PropertyCallbackInfo<void>& info) |
1851 { | 1851 { |
1852 v8::Handle<v8::Object> holder = info.Holder(); | 1852 v8::Handle<v8::Object> holder = info.Holder(); |
1853 TestObject* impl = V8TestObject::toImpl(holder); | 1853 TestObject* impl = V8TestObject::toImpl(holder); |
1854 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 1854 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
1855 impl->setCachedAttributeAnyAttribute(cppValue); | 1855 impl->setCachedAttributeAnyAttribute(cppValue); |
1856 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedAttributeAnyAttribute")); // Invalidate the cached valu
e. | 1856 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedAttributeAnyAttribute")); // Invalidate the cached valu
e. |
1857 } | 1857 } |
1858 | 1858 |
1859 static void cachedAttributeAnyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1859 static void cachedAttributeAnyAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1860 { | 1860 { |
1861 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1861 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1862 TestObjectV8Internal::cachedAttributeAnyAttributeAttributeSetter(v8Value, in
fo); | 1862 TestObjectV8Internal::cachedAttributeAnyAttributeAttributeSetter(v8Value, in
fo); |
1863 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1863 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1864 } | 1864 } |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1955 { | 1955 { |
1956 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1956 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1957 TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeGetter(in
fo); | 1957 TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeGetter(in
fo); |
1958 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1958 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1959 } | 1959 } |
1960 | 1960 |
1961 static void callWithExecutionContextAnyAttributeAttributeSetter(v8::Local<v8::Va
lue> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1961 static void callWithExecutionContextAnyAttributeAttributeSetter(v8::Local<v8::Va
lue> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1962 { | 1962 { |
1963 v8::Handle<v8::Object> holder = info.Holder(); | 1963 v8::Handle<v8::Object> holder = info.Holder(); |
1964 TestObject* impl = V8TestObject::toImpl(holder); | 1964 TestObject* impl = V8TestObject::toImpl(holder); |
1965 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 1965 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
1966 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); | 1966 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); |
1967 impl->setCallWithExecutionContextAnyAttribute(executionContext, cppValue); | 1967 impl->setCallWithExecutionContextAnyAttribute(executionContext, cppValue); |
1968 } | 1968 } |
1969 | 1969 |
1970 static void callWithExecutionContextAnyAttributeAttributeSetterCallback(v8::Loca
l<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void
>& info) | 1970 static void callWithExecutionContextAnyAttributeAttributeSetterCallback(v8::Loca
l<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void
>& info) |
1971 { | 1971 { |
1972 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1972 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1973 TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeSetter(v8
Value, info); | 1973 TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeSetter(v8
Value, info); |
1974 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1974 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1975 } | 1975 } |
(...skipping 10 matching lines...) Expand all Loading... |
1986 { | 1986 { |
1987 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1987 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1988 TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeGetter(info); | 1988 TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeGetter(info); |
1989 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1989 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1990 } | 1990 } |
1991 | 1991 |
1992 static void callWithScriptStateAnyAttributeAttributeSetter(v8::Local<v8::Value>
v8Value, const v8::PropertyCallbackInfo<void>& info) | 1992 static void callWithScriptStateAnyAttributeAttributeSetter(v8::Local<v8::Value>
v8Value, const v8::PropertyCallbackInfo<void>& info) |
1993 { | 1993 { |
1994 v8::Handle<v8::Object> holder = info.Holder(); | 1994 v8::Handle<v8::Object> holder = info.Holder(); |
1995 TestObject* impl = V8TestObject::toImpl(holder); | 1995 TestObject* impl = V8TestObject::toImpl(holder); |
1996 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 1996 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
1997 impl->setCallWithScriptStateAnyAttribute(scriptState, cppValue); | 1997 impl->setCallWithScriptStateAnyAttribute(scriptState, cppValue); |
1998 } | 1998 } |
1999 | 1999 |
2000 static void callWithScriptStateAnyAttributeAttributeSetterCallback(v8::Local<v8:
:String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& in
fo) | 2000 static void callWithScriptStateAnyAttributeAttributeSetterCallback(v8::Local<v8:
:String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& in
fo) |
2001 { | 2001 { |
2002 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 2002 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
2003 TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeSetter(v8Value
, info); | 2003 TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeSetter(v8Value
, info); |
2004 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 2004 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
2005 } | 2005 } |
2006 | 2006 |
(...skipping 10 matching lines...) Expand all Loading... |
2017 { | 2017 { |
2018 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 2018 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
2019 TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttr
ibuteGetter(info); | 2019 TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttr
ibuteGetter(info); |
2020 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 2020 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
2021 } | 2021 } |
2022 | 2022 |
2023 static void callWithExecutionContextAndScriptStateAnyAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 2023 static void callWithExecutionContextAndScriptStateAnyAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
2024 { | 2024 { |
2025 v8::Handle<v8::Object> holder = info.Holder(); | 2025 v8::Handle<v8::Object> holder = info.Holder(); |
2026 TestObject* impl = V8TestObject::toImpl(holder); | 2026 TestObject* impl = V8TestObject::toImpl(holder); |
2027 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 2027 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
2028 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); | 2028 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); |
2029 impl->setCallWithExecutionContextAndScriptStateAnyAttribute(scriptState, exe
cutionContext, cppValue); | 2029 impl->setCallWithExecutionContextAndScriptStateAnyAttribute(scriptState, exe
cutionContext, cppValue); |
2030 } | 2030 } |
2031 | 2031 |
2032 static void callWithExecutionContextAndScriptStateAnyAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) | 2032 static void callWithExecutionContextAndScriptStateAnyAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) |
2033 { | 2033 { |
2034 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 2034 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
2035 TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttr
ibuteSetter(v8Value, info); | 2035 TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttr
ibuteSetter(v8Value, info); |
2036 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 2036 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
2037 } | 2037 } |
(...skipping 996 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3034 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3034 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3035 } | 3035 } |
3036 | 3036 |
3037 static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value
, const v8::PropertyCallbackInfo<void>& info) | 3037 static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value
, const v8::PropertyCallbackInfo<void>& info) |
3038 { | 3038 { |
3039 v8::Handle<v8::Object> holder = info.Holder(); | 3039 v8::Handle<v8::Object> holder = info.Holder(); |
3040 TestObject* proxyImpl = V8TestObject::toImpl(holder); | 3040 TestObject* proxyImpl = V8TestObject::toImpl(holder); |
3041 RawPtr<TestInterfaceGarbageCollected> impl = WTF::getPtr(proxyImpl->location
GarbageCollected()); | 3041 RawPtr<TestInterfaceGarbageCollected> impl = WTF::getPtr(proxyImpl->location
GarbageCollected()); |
3042 if (!impl) | 3042 if (!impl) |
3043 return; | 3043 return; |
3044 TONATIVE_VOID(TestInterfaceGarbageCollected*, cppValue, V8TestInterfaceGarba
geCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 3044 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); |
3045 impl->setAttr1(WTF::getPtr(cppValue)); | 3045 impl->setAttr1(WTF::getPtr(cppValue)); |
3046 } | 3046 } |
3047 | 3047 |
3048 static void locationGarbageCollectedAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3048 static void locationGarbageCollectedAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3049 { | 3049 { |
3050 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3050 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3051 TestObjectV8Internal::locationGarbageCollectedAttributeSetter(v8Value, info)
; | 3051 TestObjectV8Internal::locationGarbageCollectedAttributeSetter(v8Value, info)
; |
3052 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3052 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3053 } | 3053 } |
3054 | 3054 |
(...skipping 18 matching lines...) Expand all Loading... |
3073 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3073 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3074 } | 3074 } |
3075 | 3075 |
3076 static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v
8Value, const v8::PropertyCallbackInfo<void>& info) | 3076 static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v
8Value, const v8::PropertyCallbackInfo<void>& info) |
3077 { | 3077 { |
3078 v8::Handle<v8::Object> holder = info.Holder(); | 3078 v8::Handle<v8::Object> holder = info.Holder(); |
3079 TestObject* proxyImpl = V8TestObject::toImpl(holder); | 3079 TestObject* proxyImpl = V8TestObject::toImpl(holder); |
3080 RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(p
roxyImpl->locationWillBeGarbageCollected()); | 3080 RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(p
roxyImpl->locationWillBeGarbageCollected()); |
3081 if (!impl) | 3081 if (!impl) |
3082 return; | 3082 return; |
3083 TONATIVE_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfac
eWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 3083 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); |
3084 impl->setAttr1(WTF::getPtr(cppValue)); | 3084 impl->setAttr1(WTF::getPtr(cppValue)); |
3085 } | 3085 } |
3086 | 3086 |
3087 static void locationWillBeGarbageCollectedAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& inf
o) | 3087 static void locationWillBeGarbageCollectedAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& inf
o) |
3088 { | 3088 { |
3089 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3089 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3090 TestObjectV8Internal::locationWillBeGarbageCollectedAttributeSetter(v8Value,
info); | 3090 TestObjectV8Internal::locationWillBeGarbageCollectedAttributeSetter(v8Value,
info); |
3091 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3091 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3092 } | 3092 } |
3093 | 3093 |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3207 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3207 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3208 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGet
ter(info); | 3208 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGet
ter(info); |
3209 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3209 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3210 } | 3210 } |
3211 | 3211 |
3212 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3212 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3213 { | 3213 { |
3214 v8::Handle<v8::Object> holder = info.Holder(); | 3214 v8::Handle<v8::Object> holder = info.Holder(); |
3215 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nTestInterfaceEmptyAttribute", "TestObject", holder, info.GetIsolate()); | 3215 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nTestInterfaceEmptyAttribute", "TestObject", holder, info.GetIsolate()); |
3216 TestObject* impl = V8TestObject::toImpl(holder); | 3216 TestObject* impl = V8TestObject::toImpl(holder); |
3217 TONATIVE_VOID(TestInterfaceEmpty*, cppValue, V8TestInterfaceEmpty::toImplWit
hTypeCheck(info.GetIsolate(), v8Value)); | 3217 TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(inf
o.GetIsolate(), v8Value); |
3218 impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), e
xceptionState); | 3218 impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), e
xceptionState); |
3219 exceptionState.throwIfNeeded(); | 3219 exceptionState.throwIfNeeded(); |
3220 } | 3220 } |
3221 | 3221 |
3222 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) | 3222 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) |
3223 { | 3223 { |
3224 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3224 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3225 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSet
ter(v8Value, info); | 3225 TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSet
ter(v8Value, info); |
3226 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3226 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3227 } | 3227 } |
(...skipping 23 matching lines...) Expand all Loading... |
3251 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3251 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3252 TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttrib
uteGetter(info); | 3252 TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttrib
uteGetter(info); |
3253 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3253 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3254 } | 3254 } |
3255 | 3255 |
3256 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3256 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8::
Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3257 { | 3257 { |
3258 v8::Handle<v8::Object> holder = info.Holder(); | 3258 v8::Handle<v8::Object> holder = info.Holder(); |
3259 ExceptionState exceptionState(ExceptionState::SetterContext, "cachedAttribut
eRaisesExceptionGetterAnyAttribute", "TestObject", holder, info.GetIsolate()); | 3259 ExceptionState exceptionState(ExceptionState::SetterContext, "cachedAttribut
eRaisesExceptionGetterAnyAttribute", "TestObject", holder, info.GetIsolate()); |
3260 TestObject* impl = V8TestObject::toImpl(holder); | 3260 TestObject* impl = V8TestObject::toImpl(holder); |
3261 TONATIVE_VOID(ScriptValue, cppValue, ScriptValue(ScriptState::current(info.G
etIsolate()), v8Value)); | 3261 ScriptValue cppValue = ScriptValue(ScriptState::current(info.GetIsolate()),
v8Value); |
3262 impl->setCachedAttributeRaisesExceptionGetterAnyAttribute(cppValue, exceptio
nState); | 3262 impl->setCachedAttributeRaisesExceptionGetterAnyAttribute(cppValue, exceptio
nState); |
3263 exceptionState.throwIfNeeded(); | 3263 exceptionState.throwIfNeeded(); |
3264 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedAttributeRaisesExceptionGetterAnyAttribute")); // Inval
idate the cached value. | 3264 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedAttributeRaisesExceptionGetterAnyAttribute")); // Inval
idate the cached value. |
3265 } | 3265 } |
3266 | 3266 |
3267 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallb
ack(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallb
ackInfo<void>& info) | 3267 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallb
ack(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallb
ackInfo<void>& info) |
3268 { | 3268 { |
3269 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3269 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3270 TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttrib
uteSetter(v8Value, info); | 3270 TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttrib
uteSetter(v8Value, info); |
3271 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3271 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 10 matching lines...) Expand all Loading... |
3282 { | 3282 { |
3283 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3283 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3284 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeGetter(info); | 3284 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeGetter(info); |
3285 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3285 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3286 } | 3286 } |
3287 | 3287 |
3288 static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) | 3288 static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8
Value, const v8::PropertyCallbackInfo<void>& info) |
3289 { | 3289 { |
3290 v8::Handle<v8::Object> holder = info.Holder(); | 3290 v8::Handle<v8::Object> holder = info.Holder(); |
3291 TestObject* impl = V8TestObject::toImpl(holder); | 3291 TestObject* impl = V8TestObject::toImpl(holder); |
3292 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 3292 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
3293 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3293 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3294 impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr
(cppValue)); | 3294 impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr
(cppValue)); |
3295 } | 3295 } |
3296 | 3296 |
3297 static void reflectTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) | 3297 static void reflectTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info
) |
3298 { | 3298 { |
3299 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3299 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3300 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3300 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3301 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value,
info); | 3301 TestObjectV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value,
info); |
3302 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3302 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 10 matching lines...) Expand all Loading... |
3313 { | 3313 { |
3314 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3314 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3315 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGet
ter(info); | 3315 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGet
ter(info); |
3316 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3316 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3317 } | 3317 } |
3318 | 3318 |
3319 static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3319 static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<
v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3320 { | 3320 { |
3321 v8::Handle<v8::Object> holder = info.Holder(); | 3321 v8::Handle<v8::Object> holder = info.Holder(); |
3322 TestObject* impl = V8TestObject::toImpl(holder); | 3322 TestObject* impl = V8TestObject::toImpl(holder); |
3323 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 3323 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
3324 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3324 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3325 impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppVal
ue)); | 3325 impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppVal
ue)); |
3326 } | 3326 } |
3327 | 3327 |
3328 static void reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) | 3328 static void reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(v8
::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInf
o<void>& info) |
3329 { | 3329 { |
3330 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3330 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3331 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3331 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3332 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSet
ter(v8Value, info); | 3332 TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSet
ter(v8Value, info); |
3333 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3333 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 10 matching lines...) Expand all Loading... |
3344 { | 3344 { |
3345 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 3345 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
3346 TestObjectV8Internal::reflectBooleanAttributeAttributeGetter(info); | 3346 TestObjectV8Internal::reflectBooleanAttributeAttributeGetter(info); |
3347 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3347 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
3348 } | 3348 } |
3349 | 3349 |
3350 static void reflectBooleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) | 3350 static void reflectBooleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) |
3351 { | 3351 { |
3352 v8::Handle<v8::Object> holder = info.Holder(); | 3352 v8::Handle<v8::Object> holder = info.Holder(); |
3353 TestObject* impl = V8TestObject::toImpl(holder); | 3353 TestObject* impl = V8TestObject::toImpl(holder); |
3354 TONATIVE_VOID(bool, cppValue, v8Value->BooleanValue()); | 3354 bool cppValue = v8Value->BooleanValue(); |
3355 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3355 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3356 impl->setBooleanAttribute(HTMLNames::reflectbooleanattributeAttr, cppValue); | 3356 impl->setBooleanAttribute(HTMLNames::reflectbooleanattributeAttr, cppValue); |
3357 } | 3357 } |
3358 | 3358 |
3359 static void reflectBooleanAttributeAttributeSetterCallback(v8::Local<v8::String>
, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 3359 static void reflectBooleanAttributeAttributeSetterCallback(v8::Local<v8::String>
, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
3360 { | 3360 { |
3361 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 3361 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
3362 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; | 3362 CustomElementProcessingStack::CallbackDeliveryScope deliveryScope; |
3363 TestObjectV8Internal::reflectBooleanAttributeAttributeSetter(v8Value, info); | 3363 TestObjectV8Internal::reflectBooleanAttributeAttributeSetter(v8Value, info); |
3364 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 3364 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
(...skipping 1070 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4435 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetter(v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4435 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetter(v8::Local
<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4436 { | 4436 { |
4437 v8::Handle<v8::Object> holder = info.Holder(); | 4437 v8::Handle<v8::Object> holder = info.Holder(); |
4438 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceAttribute", "TestObject", holder, info.GetIsolate()); | 4438 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceAttribute", "TestObject", holder, info.GetIsolate()); |
4439 if (!V8TestInterface::hasInstance(v8Value, info.GetIsolate())) { | 4439 if (!V8TestInterface::hasInstance(v8Value, info.GetIsolate())) { |
4440 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); | 4440 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); |
4441 exceptionState.throwIfNeeded(); | 4441 exceptionState.throwIfNeeded(); |
4442 return; | 4442 return; |
4443 } | 4443 } |
4444 TestObject* impl = V8TestObject::toImpl(holder); | 4444 TestObject* impl = V8TestObject::toImpl(holder); |
4445 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 4445 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
4446 impl->setTypeCheckingInterfaceTestInterfaceAttribute(WTF::getPtr(cppValue)); | 4446 impl->setTypeCheckingInterfaceTestInterfaceAttribute(WTF::getPtr(cppValue)); |
4447 } | 4447 } |
4448 | 4448 |
4449 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetterCallback(v
8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackIn
fo<void>& info) | 4449 static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetterCallback(v
8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackIn
fo<void>& info) |
4450 { | 4450 { |
4451 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4451 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4452 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceAttributeAttributeSe
tter(v8Value, info); | 4452 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceAttributeAttributeSe
tter(v8Value, info); |
4453 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4453 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4454 } | 4454 } |
4455 | 4455 |
(...skipping 14 matching lines...) Expand all Loading... |
4470 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetter(v8:
:Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4470 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetter(v8:
:Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4471 { | 4471 { |
4472 v8::Handle<v8::Object> holder = info.Holder(); | 4472 v8::Handle<v8::Object> holder = info.Holder(); |
4473 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceOrNullAttribute", "TestObject", holder, info.GetIsolate()); | 4473 ExceptionState exceptionState(ExceptionState::SetterContext, "typeCheckingIn
terfaceTestInterfaceOrNullAttribute", "TestObject", holder, info.GetIsolate()); |
4474 if (!isUndefinedOrNull(v8Value) && !V8TestInterface::hasInstance(v8Value, in
fo.GetIsolate())) { | 4474 if (!isUndefinedOrNull(v8Value) && !V8TestInterface::hasInstance(v8Value, in
fo.GetIsolate())) { |
4475 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); | 4475 exceptionState.throwTypeError("The provided value is not of type 'TestIn
terface'."); |
4476 exceptionState.throwIfNeeded(); | 4476 exceptionState.throwIfNeeded(); |
4477 return; | 4477 return; |
4478 } | 4478 } |
4479 TestObject* impl = V8TestObject::toImpl(holder); | 4479 TestObject* impl = V8TestObject::toImpl(holder); |
4480 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 4480 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
4481 impl->setTypeCheckingInterfaceTestInterfaceOrNullAttribute(WTF::getPtr(cppVa
lue)); | 4481 impl->setTypeCheckingInterfaceTestInterfaceOrNullAttribute(WTF::getPtr(cppVa
lue)); |
4482 } | 4482 } |
4483 | 4483 |
4484 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetterCall
back(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCall
backInfo<void>& info) | 4484 static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetterCall
back(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCall
backInfo<void>& info) |
4485 { | 4485 { |
4486 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4486 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4487 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceOrNullAttributeAttri
buteSetter(v8Value, info); | 4487 TestObjectV8Internal::typeCheckingInterfaceTestInterfaceOrNullAttributeAttri
buteSetter(v8Value, info); |
4488 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4488 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4489 } | 4489 } |
4490 | 4490 |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4591 { | 4591 { |
4592 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4592 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4593 TestObjectV8Internal::testInterfaceAttributeAttributeGetter(info); | 4593 TestObjectV8Internal::testInterfaceAttributeAttributeGetter(info); |
4594 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4594 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4595 } | 4595 } |
4596 | 4596 |
4597 static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) | 4597 static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value,
const v8::PropertyCallbackInfo<void>& info) |
4598 { | 4598 { |
4599 v8::Handle<v8::Object> holder = info.Holder(); | 4599 v8::Handle<v8::Object> holder = info.Holder(); |
4600 TestObject* impl = V8TestObject::toImpl(holder); | 4600 TestObject* impl = V8TestObject::toImpl(holder); |
4601 TONATIVE_VOID(TestInterfaceImplementation*, cppValue, V8TestInterface::toImp
lWithTypeCheck(info.GetIsolate(), v8Value)); | 4601 TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck
(info.GetIsolate(), v8Value); |
4602 impl->setTestInterfaceAttribute(WTF::getPtr(cppValue)); | 4602 impl->setTestInterfaceAttribute(WTF::getPtr(cppValue)); |
4603 } | 4603 } |
4604 | 4604 |
4605 static void testInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4605 static void testInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4606 { | 4606 { |
4607 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4607 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4608 TestObjectV8Internal::testInterfaceAttributeAttributeSetter(v8Value, info); | 4608 TestObjectV8Internal::testInterfaceAttributeAttributeSetter(v8Value, info); |
4609 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4609 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4610 } | 4610 } |
4611 | 4611 |
4612 static void testInterfaceGarbageCollectedAttributeAttributeGetter(const v8::Prop
ertyCallbackInfo<v8::Value>& info) | 4612 static void testInterfaceGarbageCollectedAttributeAttributeGetter(const v8::Prop
ertyCallbackInfo<v8::Value>& info) |
4613 { | 4613 { |
4614 v8::Handle<v8::Object> holder = info.Holder(); | 4614 v8::Handle<v8::Object> holder = info.Holder(); |
4615 TestObject* impl = V8TestObject::toImpl(holder); | 4615 TestObject* impl = V8TestObject::toImpl(holder); |
4616 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedAt
tribute()), impl); | 4616 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedAt
tribute()), impl); |
4617 } | 4617 } |
4618 | 4618 |
4619 static void testInterfaceGarbageCollectedAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4619 static void testInterfaceGarbageCollectedAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4620 { | 4620 { |
4621 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4621 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4622 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeGetter(
info); | 4622 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeGetter(
info); |
4623 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4623 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4624 } | 4624 } |
4625 | 4625 |
4626 static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::
Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4626 static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::
Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4627 { | 4627 { |
4628 v8::Handle<v8::Object> holder = info.Holder(); | 4628 v8::Handle<v8::Object> holder = info.Holder(); |
4629 TestObject* impl = V8TestObject::toImpl(holder); | 4629 TestObject* impl = V8TestObject::toImpl(holder); |
4630 TONATIVE_VOID(TestInterfaceGarbageCollected*, cppValue, V8TestInterfaceGarba
geCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 4630 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); |
4631 impl->setTestInterfaceGarbageCollectedAttribute(WTF::getPtr(cppValue)); | 4631 impl->setTestInterfaceGarbageCollectedAttribute(WTF::getPtr(cppValue)); |
4632 } | 4632 } |
4633 | 4633 |
4634 static void testInterfaceGarbageCollectedAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<vo
id>& info) | 4634 static void testInterfaceGarbageCollectedAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<vo
id>& info) |
4635 { | 4635 { |
4636 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4636 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4637 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeSetter(
v8Value, info); | 4637 TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeSetter(
v8Value, info); |
4638 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4638 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4639 } | 4639 } |
4640 | 4640 |
4641 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) | 4641 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) |
4642 { | 4642 { |
4643 v8::Handle<v8::Object> holder = info.Holder(); | 4643 v8::Handle<v8::Object> holder = info.Holder(); |
4644 TestObject* impl = V8TestObject::toImpl(holder); | 4644 TestObject* impl = V8TestObject::toImpl(holder); |
4645 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedOr
NullAttribute()), impl); | 4645 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceGarbageCollectedOr
NullAttribute()), impl); |
4646 } | 4646 } |
4647 | 4647 |
4648 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4648 static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4649 { | 4649 { |
4650 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4650 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4651 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeG
etter(info); | 4651 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeG
etter(info); |
4652 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4652 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4653 } | 4653 } |
4654 | 4654 |
4655 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4655 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4656 { | 4656 { |
4657 v8::Handle<v8::Object> holder = info.Holder(); | 4657 v8::Handle<v8::Object> holder = info.Holder(); |
4658 TestObject* impl = V8TestObject::toImpl(holder); | 4658 TestObject* impl = V8TestObject::toImpl(holder); |
4659 TONATIVE_VOID(TestInterfaceGarbageCollected*, cppValue, V8TestInterfaceGarba
geCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 4659 TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::t
oImplWithTypeCheck(info.GetIsolate(), v8Value); |
4660 impl->setTestInterfaceGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue))
; | 4660 impl->setTestInterfaceGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue))
; |
4661 } | 4661 } |
4662 | 4662 |
4663 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) | 4663 static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) |
4664 { | 4664 { |
4665 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4665 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4666 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeS
etter(v8Value, info); | 4666 TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeS
etter(v8Value, info); |
4667 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4667 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4668 } | 4668 } |
4669 | 4669 |
4670 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) | 4670 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(const v8
::PropertyCallbackInfo<v8::Value>& info) |
4671 { | 4671 { |
4672 v8::Handle<v8::Object> holder = info.Holder(); | 4672 v8::Handle<v8::Object> holder = info.Holder(); |
4673 TestObject* impl = V8TestObject::toImpl(holder); | 4673 TestObject* impl = V8TestObject::toImpl(holder); |
4674 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedAttribute()), impl); | 4674 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedAttribute()), impl); |
4675 } | 4675 } |
4676 | 4676 |
4677 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4677 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback(
v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4678 { | 4678 { |
4679 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4679 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4680 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeG
etter(info); | 4680 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeG
etter(info); |
4681 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4681 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4682 } | 4682 } |
4683 | 4683 |
4684 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4684 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4685 { | 4685 { |
4686 v8::Handle<v8::Object> holder = info.Holder(); | 4686 v8::Handle<v8::Object> holder = info.Holder(); |
4687 TestObject* impl = V8TestObject::toImpl(holder); | 4687 TestObject* impl = V8TestObject::toImpl(holder); |
4688 TONATIVE_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfac
eWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 4688 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); |
4689 impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue))
; | 4689 impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue))
; |
4690 } | 4690 } |
4691 | 4691 |
4692 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) | 4692 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback(
v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackI
nfo<void>& info) |
4693 { | 4693 { |
4694 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4694 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4695 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeS
etter(v8Value, info); | 4695 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeS
etter(v8Value, info); |
4696 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4696 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4697 } | 4697 } |
4698 | 4698 |
4699 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 4699 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
4700 { | 4700 { |
4701 v8::Handle<v8::Object> holder = info.Holder(); | 4701 v8::Handle<v8::Object> holder = info.Holder(); |
4702 TestObject* impl = V8TestObject::toImpl(holder); | 4702 TestObject* impl = V8TestObject::toImpl(holder); |
4703 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedOrNullAttribute()), impl); | 4703 v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageColle
ctedOrNullAttribute()), impl); |
4704 } | 4704 } |
4705 | 4705 |
4706 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 4706 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
4707 { | 4707 { |
4708 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4708 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4709 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteGetter(info); | 4709 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteGetter(info); |
4710 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4710 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4711 } | 4711 } |
4712 | 4712 |
4713 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4713 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4714 { | 4714 { |
4715 v8::Handle<v8::Object> holder = info.Holder(); | 4715 v8::Handle<v8::Object> holder = info.Holder(); |
4716 TestObject* impl = V8TestObject::toImpl(holder); | 4716 TestObject* impl = V8TestObject::toImpl(holder); |
4717 TONATIVE_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfac
eWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value)); | 4717 TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbage
Collected::toImplWithTypeCheck(info.GetIsolate(), v8Value); |
4718 impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppV
alue)); | 4718 impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppV
alue)); |
4719 } | 4719 } |
4720 | 4720 |
4721 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) | 4721 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCal
lbackInfo<void>& info) |
4722 { | 4722 { |
4723 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4723 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4724 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteSetter(v8Value, info); | 4724 TestObjectV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttr
ibuteSetter(v8Value, info); |
4725 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4725 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4726 } | 4726 } |
4727 | 4727 |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4821 { | 4821 { |
4822 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 4822 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
4823 TestObjectV8Internal::nodeAttributeAttributeGetter(info); | 4823 TestObjectV8Internal::nodeAttributeAttributeGetter(info); |
4824 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4824 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4825 } | 4825 } |
4826 | 4826 |
4827 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) | 4827 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:
:PropertyCallbackInfo<void>& info) |
4828 { | 4828 { |
4829 v8::Handle<v8::Object> holder = info.Holder(); | 4829 v8::Handle<v8::Object> holder = info.Holder(); |
4830 TestObject* impl = V8TestObject::toImpl(holder); | 4830 TestObject* impl = V8TestObject::toImpl(holder); |
4831 TONATIVE_VOID(Node*, cppValue, V8Node::toImplWithTypeCheck(info.GetIsolate()
, v8Value)); | 4831 Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value); |
4832 V8TestObject::PrivateScript::nodeAttributeAttributeSetter(toFrameIfNotDetach
ed(info.GetIsolate()->GetCurrentContext()), impl, cppValue); | 4832 V8TestObject::PrivateScript::nodeAttributeAttributeSetter(toFrameIfNotDetach
ed(info.GetIsolate()->GetCurrentContext()), impl, cppValue); |
4833 } | 4833 } |
4834 | 4834 |
4835 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 4835 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
4836 { | 4836 { |
4837 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 4837 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
4838 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); | 4838 TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info); |
4839 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 4839 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
4840 } | 4840 } |
4841 | 4841 |
(...skipping 446 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5288 | 5288 |
5289 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 5289 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
5290 { | 5290 { |
5291 if (UNLIKELY(info.Length() < 1)) { | 5291 if (UNLIKELY(info.Length() < 1)) { |
5292 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodBooleanArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); | 5292 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodBooleanArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); |
5293 return; | 5293 return; |
5294 } | 5294 } |
5295 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5295 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5296 bool booleanArg; | 5296 bool booleanArg; |
5297 { | 5297 { |
5298 v8::TryCatch block; | 5298 booleanArg = info[0]->BooleanValue(); |
5299 V8RethrowTryCatchScope rethrow(block); | |
5300 TONATIVE_VOID_INTERNAL(booleanArg, info[0]->BooleanValue()); | |
5301 } | 5299 } |
5302 impl->voidMethodBooleanArg(booleanArg); | 5300 impl->voidMethodBooleanArg(booleanArg); |
5303 } | 5301 } |
5304 | 5302 |
5305 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 5303 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
5306 { | 5304 { |
5307 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5305 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5308 TestObjectV8Internal::voidMethodBooleanArgMethod(info); | 5306 TestObjectV8Internal::voidMethodBooleanArgMethod(info); |
5309 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5307 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5310 } | 5308 } |
(...skipping 243 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5554 | 5552 |
5555 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 5553 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
5556 { | 5554 { |
5557 if (UNLIKELY(info.Length() < 1)) { | 5555 if (UNLIKELY(info.Length() < 1)) { |
5558 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate
()), info.GetIsolate()); | 5556 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate
()), info.GetIsolate()); |
5559 return; | 5557 return; |
5560 } | 5558 } |
5561 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5559 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5562 TestInterfaceEmpty* testInterfaceEmptyArg; | 5560 TestInterfaceEmpty* testInterfaceEmptyArg; |
5563 { | 5561 { |
5564 v8::TryCatch block; | 5562 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
5565 V8RethrowTryCatchScope rethrow(block); | |
5566 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
5567 } | 5563 } |
5568 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); | 5564 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); |
5569 } | 5565 } |
5570 | 5566 |
5571 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 5567 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
5572 { | 5568 { |
5573 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5569 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5574 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); | 5570 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); |
5575 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5571 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5576 } | 5572 } |
5577 | 5573 |
5578 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 5574 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
5579 { | 5575 { |
5580 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); | 5576 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); |
5581 if (UNLIKELY(info.Length() < 2)) { | 5577 if (UNLIKELY(info.Length() < 2)) { |
5582 setMinimumArityTypeError(exceptionState, 2, info.Length()); | 5578 setMinimumArityTypeError(exceptionState, 2, info.Length()); |
5583 exceptionState.throwIfNeeded(); | 5579 exceptionState.throwIfNeeded(); |
5584 return; | 5580 return; |
5585 } | 5581 } |
5586 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5582 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5587 int longArg; | 5583 int longArg; |
5588 TestInterfaceEmpty* testInterfaceEmptyArg; | 5584 TestInterfaceEmpty* testInterfaceEmptyArg; |
5589 { | 5585 { |
5590 v8::TryCatch block; | |
5591 V8RethrowTryCatchScope rethrow(block); | |
5592 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 5586 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
5593 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[1])); | 5587 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[1]); |
5594 } | 5588 } |
5595 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg)
; | 5589 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg)
; |
5596 } | 5590 } |
5597 | 5591 |
5598 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 5592 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
5599 { | 5593 { |
5600 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5594 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5601 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info); | 5595 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info); |
5602 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5596 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5603 } | 5597 } |
(...skipping 28 matching lines...) Expand all Loading... |
5632 { | 5626 { |
5633 if (UNLIKELY(info.Length() < 1)) { | 5627 if (UNLIKELY(info.Length() < 1)) { |
5634 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodVoidCallbackFunctionArg", "TestObject", 1, info.Length(), info.GetIsola
te()), info.GetIsolate()); | 5628 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodVoidCallbackFunctionArg", "TestObject", 1, info.Length(), info.GetIsola
te()), info.GetIsolate()); |
5635 return; | 5629 return; |
5636 } | 5630 } |
5637 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5631 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5638 ScriptValue voidCallbackFunctionArg; | 5632 ScriptValue voidCallbackFunctionArg; |
5639 { | 5633 { |
5640 v8::TryCatch block; | 5634 v8::TryCatch block; |
5641 V8RethrowTryCatchScope rethrow(block); | 5635 V8RethrowTryCatchScope rethrow(block); |
5642 TONATIVE_VOID_INTERNAL(voidCallbackFunctionArg, ScriptValue(ScriptState:
:current(info.GetIsolate()), info[0])); | 5636 voidCallbackFunctionArg = ScriptValue(ScriptState::current(info.GetIsola
te()), info[0]); |
5643 } | 5637 } |
5644 impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg); | 5638 impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg); |
5645 } | 5639 } |
5646 | 5640 |
5647 static void voidMethodVoidCallbackFunctionArgMethodCallback(const v8::FunctionCa
llbackInfo<v8::Value>& info) | 5641 static void voidMethodVoidCallbackFunctionArgMethodCallback(const v8::FunctionCa
llbackInfo<v8::Value>& info) |
5648 { | 5642 { |
5649 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5643 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5650 TestObjectV8Internal::voidMethodVoidCallbackFunctionArgMethod(info); | 5644 TestObjectV8Internal::voidMethodVoidCallbackFunctionArgMethod(info); |
5651 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5645 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5652 } | 5646 } |
5653 | 5647 |
5654 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::Function
CallbackInfo<v8::Value>& info) | 5648 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::Function
CallbackInfo<v8::Value>& info) |
5655 { | 5649 { |
5656 if (UNLIKELY(info.Length() < 1)) { | 5650 if (UNLIKELY(info.Length() < 1)) { |
5657 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAnyCallbackFunctionOptionalAnyArg", "TestObject", 1, info.Length(), inf
o.GetIsolate()), info.GetIsolate()); | 5651 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAnyCallbackFunctionOptionalAnyArg", "TestObject", 1, info.Length(), inf
o.GetIsolate()), info.GetIsolate()); |
5658 return; | 5652 return; |
5659 } | 5653 } |
5660 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5654 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5661 ScriptValue anyCallbackFunctionOptionalAnyArgArg; | 5655 ScriptValue anyCallbackFunctionOptionalAnyArgArg; |
5662 { | 5656 { |
5663 v8::TryCatch block; | 5657 v8::TryCatch block; |
5664 V8RethrowTryCatchScope rethrow(block); | 5658 V8RethrowTryCatchScope rethrow(block); |
5665 TONATIVE_VOID_INTERNAL(anyCallbackFunctionOptionalAnyArgArg, ScriptValue
(ScriptState::current(info.GetIsolate()), info[0])); | 5659 anyCallbackFunctionOptionalAnyArgArg = ScriptValue(ScriptState::current(
info.GetIsolate()), info[0]); |
5666 } | 5660 } |
5667 impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptiona
lAnyArgArg); | 5661 impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptiona
lAnyArgArg); |
5668 } | 5662 } |
5669 | 5663 |
5670 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback(const v8::
FunctionCallbackInfo<v8::Value>& info) | 5664 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback(const v8::
FunctionCallbackInfo<v8::Value>& info) |
5671 { | 5665 { |
5672 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5666 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5673 TestObjectV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethod(info
); | 5667 TestObjectV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethod(info
); |
5674 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5668 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5675 } | 5669 } |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5725 | 5719 |
5726 static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 5720 static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
5727 { | 5721 { |
5728 if (UNLIKELY(info.Length() < 1)) { | 5722 if (UNLIKELY(info.Length() < 1)) { |
5729 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodEventTargetArg", "TestObject", 1, info.Length(), info.GetIsolate()), in
fo.GetIsolate()); | 5723 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodEventTargetArg", "TestObject", 1, info.Length(), info.GetIsolate()), in
fo.GetIsolate()); |
5730 return; | 5724 return; |
5731 } | 5725 } |
5732 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5726 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5733 EventTarget* eventTargetArg; | 5727 EventTarget* eventTargetArg; |
5734 { | 5728 { |
5735 v8::TryCatch block; | 5729 eventTargetArg = V8DOMWrapper::isDOMWrapper(info[0]) ? toWrapperTypeInfo
(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8::Handle<v8::Object>::C
ast(info[0])) : 0; |
5736 V8RethrowTryCatchScope rethrow(block); | |
5737 TONATIVE_VOID_INTERNAL(eventTargetArg, V8DOMWrapper::isDOMWrapper(info[0
]) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8:
:Handle<v8::Object>::Cast(info[0])) : 0); | |
5738 } | 5730 } |
5739 impl->voidMethodEventTargetArg(eventTargetArg); | 5731 impl->voidMethodEventTargetArg(eventTargetArg); |
5740 } | 5732 } |
5741 | 5733 |
5742 static void voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 5734 static void voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
5743 { | 5735 { |
5744 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5736 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5745 TestObjectV8Internal::voidMethodEventTargetArgMethod(info); | 5737 TestObjectV8Internal::voidMethodEventTargetArgMethod(info); |
5746 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5738 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5747 } | 5739 } |
5748 | 5740 |
5749 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in
fo) | 5741 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in
fo) |
5750 { | 5742 { |
5751 if (UNLIKELY(info.Length() < 1)) { | 5743 if (UNLIKELY(info.Length() < 1)) { |
5752 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAnyArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetIs
olate()); | 5744 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAnyArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetIs
olate()); |
5753 return; | 5745 return; |
5754 } | 5746 } |
5755 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5747 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5756 ScriptValue anyArg; | 5748 ScriptValue anyArg; |
5757 { | 5749 { |
5758 v8::TryCatch block; | 5750 v8::TryCatch block; |
5759 V8RethrowTryCatchScope rethrow(block); | 5751 V8RethrowTryCatchScope rethrow(block); |
5760 TONATIVE_VOID_INTERNAL(anyArg, ScriptValue(ScriptState::current(info.Get
Isolate()), info[0])); | 5752 anyArg = ScriptValue(ScriptState::current(info.GetIsolate()), info[0]); |
5761 } | 5753 } |
5762 impl->voidMethodAnyArg(anyArg); | 5754 impl->voidMethodAnyArg(anyArg); |
5763 } | 5755 } |
5764 | 5756 |
5765 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 5757 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
5766 { | 5758 { |
5767 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5759 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5768 TestObjectV8Internal::voidMethodAnyArgMethod(info); | 5760 TestObjectV8Internal::voidMethodAnyArgMethod(info); |
5769 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5761 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5770 } | 5762 } |
5771 | 5763 |
5772 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5764 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
5773 { | 5765 { |
5774 if (UNLIKELY(info.Length() < 1)) { | 5766 if (UNLIKELY(info.Length() < 1)) { |
5775 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAttrArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); | 5767 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodAttrArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); |
5776 return; | 5768 return; |
5777 } | 5769 } |
5778 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5770 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5779 Attr* attrArg; | 5771 Attr* attrArg; |
5780 { | 5772 { |
5781 v8::TryCatch block; | 5773 attrArg = V8Attr::toImplWithTypeCheck(info.GetIsolate(), info[0]); |
5782 V8RethrowTryCatchScope rethrow(block); | |
5783 TONATIVE_VOID_INTERNAL(attrArg, V8Attr::toImplWithTypeCheck(info.GetIsol
ate(), info[0])); | |
5784 } | 5774 } |
5785 impl->voidMethodAttrArg(attrArg); | 5775 impl->voidMethodAttrArg(attrArg); |
5786 } | 5776 } |
5787 | 5777 |
5788 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5778 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5789 { | 5779 { |
5790 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5780 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5791 TestObjectV8Internal::voidMethodAttrArgMethod(info); | 5781 TestObjectV8Internal::voidMethodAttrArgMethod(info); |
5792 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5782 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5793 } | 5783 } |
5794 | 5784 |
5795 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 5785 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
5796 { | 5786 { |
5797 if (UNLIKELY(info.Length() < 1)) { | 5787 if (UNLIKELY(info.Length() < 1)) { |
5798 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.
GetIsolate()); | 5788 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.
GetIsolate()); |
5799 return; | 5789 return; |
5800 } | 5790 } |
5801 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5791 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5802 Document* documentArg; | 5792 Document* documentArg; |
5803 { | 5793 { |
5804 v8::TryCatch block; | 5794 documentArg = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]
); |
5805 V8RethrowTryCatchScope rethrow(block); | |
5806 TONATIVE_VOID_INTERNAL(documentArg, V8Document::toImplWithTypeCheck(info
.GetIsolate(), info[0])); | |
5807 } | 5795 } |
5808 impl->voidMethodDocumentArg(documentArg); | 5796 impl->voidMethodDocumentArg(documentArg); |
5809 } | 5797 } |
5810 | 5798 |
5811 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 5799 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
5812 { | 5800 { |
5813 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5801 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5814 TestObjectV8Internal::voidMethodDocumentArgMethod(info); | 5802 TestObjectV8Internal::voidMethodDocumentArgMethod(info); |
5815 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5803 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5816 } | 5804 } |
5817 | 5805 |
5818 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5806 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5819 { | 5807 { |
5820 if (UNLIKELY(info.Length() < 1)) { | 5808 if (UNLIKELY(info.Length() < 1)) { |
5821 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); | 5809 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); |
5822 return; | 5810 return; |
5823 } | 5811 } |
5824 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5812 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5825 DocumentType* documentTypeArg; | 5813 DocumentType* documentTypeArg; |
5826 { | 5814 { |
5827 v8::TryCatch block; | 5815 documentTypeArg = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(),
info[0]); |
5828 V8RethrowTryCatchScope rethrow(block); | |
5829 TONATIVE_VOID_INTERNAL(documentTypeArg, V8DocumentType::toImplWithTypeCh
eck(info.GetIsolate(), info[0])); | |
5830 } | 5816 } |
5831 impl->voidMethodDocumentTypeArg(documentTypeArg); | 5817 impl->voidMethodDocumentTypeArg(documentTypeArg); |
5832 } | 5818 } |
5833 | 5819 |
5834 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 5820 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
5835 { | 5821 { |
5836 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5822 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5837 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info); | 5823 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info); |
5838 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5824 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5839 } | 5825 } |
5840 | 5826 |
5841 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 5827 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
5842 { | 5828 { |
5843 if (UNLIKELY(info.Length() < 1)) { | 5829 if (UNLIKELY(info.Length() < 1)) { |
5844 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodElementArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); | 5830 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodElementArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.G
etIsolate()); |
5845 return; | 5831 return; |
5846 } | 5832 } |
5847 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5833 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5848 Element* elementArg; | 5834 Element* elementArg; |
5849 { | 5835 { |
5850 v8::TryCatch block; | 5836 elementArg = V8Element::toImplWithTypeCheck(info.GetIsolate(), info[0]); |
5851 V8RethrowTryCatchScope rethrow(block); | |
5852 TONATIVE_VOID_INTERNAL(elementArg, V8Element::toImplWithTypeCheck(info.G
etIsolate(), info[0])); | |
5853 } | 5837 } |
5854 impl->voidMethodElementArg(elementArg); | 5838 impl->voidMethodElementArg(elementArg); |
5855 } | 5839 } |
5856 | 5840 |
5857 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 5841 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
5858 { | 5842 { |
5859 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5843 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5860 TestObjectV8Internal::voidMethodElementArgMethod(info); | 5844 TestObjectV8Internal::voidMethodElementArgMethod(info); |
5861 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5845 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5862 } | 5846 } |
5863 | 5847 |
5864 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5848 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
5865 { | 5849 { |
5866 if (UNLIKELY(info.Length() < 1)) { | 5850 if (UNLIKELY(info.Length() < 1)) { |
5867 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodNodeArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); | 5851 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodNodeArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetI
solate()); |
5868 return; | 5852 return; |
5869 } | 5853 } |
5870 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5854 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5871 Node* nodeArg; | 5855 Node* nodeArg; |
5872 { | 5856 { |
5873 v8::TryCatch block; | 5857 nodeArg = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]); |
5874 V8RethrowTryCatchScope rethrow(block); | |
5875 TONATIVE_VOID_INTERNAL(nodeArg, V8Node::toImplWithTypeCheck(info.GetIsol
ate(), info[0])); | |
5876 } | 5858 } |
5877 impl->voidMethodNodeArg(nodeArg); | 5859 impl->voidMethodNodeArg(nodeArg); |
5878 } | 5860 } |
5879 | 5861 |
5880 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5862 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5881 { | 5863 { |
5882 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5864 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5883 TestObjectV8Internal::voidMethodNodeArgMethod(info); | 5865 TestObjectV8Internal::voidMethodNodeArgMethod(info); |
5884 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5866 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5885 } | 5867 } |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5951 | 5933 |
5952 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 5934 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
5953 { | 5935 { |
5954 if (UNLIKELY(info.Length() < 1)) { | 5936 if (UNLIKELY(info.Length() < 1)) { |
5955 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferArg", "TestObject", 1, info.Length(), info.GetIsolate()), in
fo.GetIsolate()); | 5937 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferArg", "TestObject", 1, info.Length(), info.GetIsolate()), in
fo.GetIsolate()); |
5956 return; | 5938 return; |
5957 } | 5939 } |
5958 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5940 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5959 ArrayBuffer* arrayBufferArg; | 5941 ArrayBuffer* arrayBufferArg; |
5960 { | 5942 { |
5961 v8::TryCatch block; | 5943 arrayBufferArg = info[0]->IsArrayBuffer() ? V8ArrayBuffer::toImpl(v8::Ha
ndle<v8::ArrayBuffer>::Cast(info[0])) : 0; |
5962 V8RethrowTryCatchScope rethrow(block); | |
5963 TONATIVE_VOID_INTERNAL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8Arra
yBuffer::toImpl(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); | |
5964 } | 5944 } |
5965 impl->voidMethodArrayBufferArg(arrayBufferArg); | 5945 impl->voidMethodArrayBufferArg(arrayBufferArg); |
5966 } | 5946 } |
5967 | 5947 |
5968 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 5948 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
5969 { | 5949 { |
5970 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5950 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5971 TestObjectV8Internal::voidMethodArrayBufferArgMethod(info); | 5951 TestObjectV8Internal::voidMethodArrayBufferArgMethod(info); |
5972 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5952 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5973 } | 5953 } |
5974 | 5954 |
5975 static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) | 5955 static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) |
5976 { | 5956 { |
5977 if (UNLIKELY(info.Length() < 1)) { | 5957 if (UNLIKELY(info.Length() < 1)) { |
5978 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate(
)), info.GetIsolate()); | 5958 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate(
)), info.GetIsolate()); |
5979 return; | 5959 return; |
5980 } | 5960 } |
5981 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5961 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
5982 ArrayBuffer* arrayBufferArg; | 5962 ArrayBuffer* arrayBufferArg; |
5983 { | 5963 { |
5984 v8::TryCatch block; | 5964 arrayBufferArg = info[0]->IsArrayBuffer() ? V8ArrayBuffer::toImpl(v8::Ha
ndle<v8::ArrayBuffer>::Cast(info[0])) : 0; |
5985 V8RethrowTryCatchScope rethrow(block); | |
5986 TONATIVE_VOID_INTERNAL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8Arra
yBuffer::toImpl(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); | |
5987 } | 5965 } |
5988 impl->voidMethodArrayBufferOrNullArg(arrayBufferArg); | 5966 impl->voidMethodArrayBufferOrNullArg(arrayBufferArg); |
5989 } | 5967 } |
5990 | 5968 |
5991 static void voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 5969 static void voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
5992 { | 5970 { |
5993 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5971 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
5994 TestObjectV8Internal::voidMethodArrayBufferOrNullArgMethod(info); | 5972 TestObjectV8Internal::voidMethodArrayBufferOrNullArgMethod(info); |
5995 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5973 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
5996 } | 5974 } |
5997 | 5975 |
5998 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) | 5976 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) |
5999 { | 5977 { |
6000 if (UNLIKELY(info.Length() < 1)) { | 5978 if (UNLIKELY(info.Length() < 1)) { |
6001 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferViewArg", "TestObject", 1, info.Length(), info.GetIsolate())
, info.GetIsolate()); | 5979 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayBufferViewArg", "TestObject", 1, info.Length(), info.GetIsolate())
, info.GetIsolate()); |
6002 return; | 5980 return; |
6003 } | 5981 } |
6004 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 5982 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6005 ArrayBufferView* arrayBufferViewArg; | 5983 ArrayBufferView* arrayBufferViewArg; |
6006 { | 5984 { |
6007 v8::TryCatch block; | 5985 arrayBufferViewArg = info[0]->IsArrayBufferView() ? V8ArrayBufferView::t
oImpl(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0; |
6008 V8RethrowTryCatchScope rethrow(block); | |
6009 TONATIVE_VOID_INTERNAL(arrayBufferViewArg, info[0]->IsArrayBufferView()
? V8ArrayBufferView::toImpl(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0)
; | |
6010 } | 5986 } |
6011 impl->voidMethodArrayBufferViewArg(arrayBufferViewArg); | 5987 impl->voidMethodArrayBufferViewArg(arrayBufferViewArg); |
6012 } | 5988 } |
6013 | 5989 |
6014 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 5990 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
6015 { | 5991 { |
6016 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 5992 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6017 TestObjectV8Internal::voidMethodArrayBufferViewArgMethod(info); | 5993 TestObjectV8Internal::voidMethodArrayBufferViewArgMethod(info); |
6018 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 5994 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6019 } | 5995 } |
6020 | 5996 |
6021 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5997 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
6022 { | 5998 { |
6023 if (UNLIKELY(info.Length() < 1)) { | 5999 if (UNLIKELY(info.Length() < 1)) { |
6024 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodFloat32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); | 6000 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodFloat32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); |
6025 return; | 6001 return; |
6026 } | 6002 } |
6027 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6003 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6028 Float32Array* float32ArrayArg; | 6004 Float32Array* float32ArrayArg; |
6029 { | 6005 { |
6030 v8::TryCatch block; | 6006 float32ArrayArg = info[0]->IsFloat32Array() ? V8Float32Array::toImpl(v8:
:Handle<v8::Float32Array>::Cast(info[0])) : 0; |
6031 V8RethrowTryCatchScope rethrow(block); | |
6032 TONATIVE_VOID_INTERNAL(float32ArrayArg, info[0]->IsFloat32Array() ? V8Fl
oat32Array::toImpl(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0); | |
6033 } | 6007 } |
6034 impl->voidMethodFloat32ArrayArg(float32ArrayArg); | 6008 impl->voidMethodFloat32ArrayArg(float32ArrayArg); |
6035 } | 6009 } |
6036 | 6010 |
6037 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 6011 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
6038 { | 6012 { |
6039 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6013 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6040 TestObjectV8Internal::voidMethodFloat32ArrayArgMethod(info); | 6014 TestObjectV8Internal::voidMethodFloat32ArrayArgMethod(info); |
6041 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6015 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6042 } | 6016 } |
6043 | 6017 |
6044 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 6018 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
6045 { | 6019 { |
6046 if (UNLIKELY(info.Length() < 1)) { | 6020 if (UNLIKELY(info.Length() < 1)) { |
6047 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodInt32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), inf
o.GetIsolate()); | 6021 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodInt32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), inf
o.GetIsolate()); |
6048 return; | 6022 return; |
6049 } | 6023 } |
6050 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6024 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6051 Int32Array* int32ArrayArg; | 6025 Int32Array* int32ArrayArg; |
6052 { | 6026 { |
6053 v8::TryCatch block; | 6027 int32ArrayArg = info[0]->IsInt32Array() ? V8Int32Array::toImpl(v8::Handl
e<v8::Int32Array>::Cast(info[0])) : 0; |
6054 V8RethrowTryCatchScope rethrow(block); | |
6055 TONATIVE_VOID_INTERNAL(int32ArrayArg, info[0]->IsInt32Array() ? V8Int32A
rray::toImpl(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0); | |
6056 } | 6028 } |
6057 impl->voidMethodInt32ArrayArg(int32ArrayArg); | 6029 impl->voidMethodInt32ArrayArg(int32ArrayArg); |
6058 } | 6030 } |
6059 | 6031 |
6060 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 6032 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
6061 { | 6033 { |
6062 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6034 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6063 TestObjectV8Internal::voidMethodInt32ArrayArgMethod(info); | 6035 TestObjectV8Internal::voidMethodInt32ArrayArgMethod(info); |
6064 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6036 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6065 } | 6037 } |
6066 | 6038 |
6067 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 6039 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
6068 { | 6040 { |
6069 if (UNLIKELY(info.Length() < 1)) { | 6041 if (UNLIKELY(info.Length() < 1)) { |
6070 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodUint8ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), inf
o.GetIsolate()); | 6042 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodUint8ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()), inf
o.GetIsolate()); |
6071 return; | 6043 return; |
6072 } | 6044 } |
6073 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6045 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6074 Uint8Array* uint8ArrayArg; | 6046 Uint8Array* uint8ArrayArg; |
6075 { | 6047 { |
6076 v8::TryCatch block; | 6048 uint8ArrayArg = info[0]->IsUint8Array() ? V8Uint8Array::toImpl(v8::Handl
e<v8::Uint8Array>::Cast(info[0])) : 0; |
6077 V8RethrowTryCatchScope rethrow(block); | |
6078 TONATIVE_VOID_INTERNAL(uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8A
rray::toImpl(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0); | |
6079 } | 6049 } |
6080 impl->voidMethodUint8ArrayArg(uint8ArrayArg); | 6050 impl->voidMethodUint8ArrayArg(uint8ArrayArg); |
6081 } | 6051 } |
6082 | 6052 |
6083 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 6053 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
6084 { | 6054 { |
6085 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6055 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6086 TestObjectV8Internal::voidMethodUint8ArrayArgMethod(info); | 6056 TestObjectV8Internal::voidMethodUint8ArrayArgMethod(info); |
6087 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6057 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6088 } | 6058 } |
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6442 | 6412 |
6443 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 6413 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
6444 { | 6414 { |
6445 if (UNLIKELY(info.Length() < 1)) { | 6415 if (UNLIKELY(info.Length() < 1)) { |
6446 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()); |
6447 return; | 6417 return; |
6448 } | 6418 } |
6449 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6419 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6450 TestInterfaceEmpty* nullableTestInterfaceEmptyArg; | 6420 TestInterfaceEmpty* nullableTestInterfaceEmptyArg; |
6451 { | 6421 { |
6452 v8::TryCatch block; | 6422 nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeChec
k(info.GetIsolate(), info[0]); |
6453 V8RethrowTryCatchScope rethrow(block); | |
6454 TONATIVE_VOID_INTERNAL(nullableTestInterfaceEmptyArg, V8TestInterfaceEmp
ty::toImplWithTypeCheck(info.GetIsolate(), info[0])); | |
6455 } | 6423 } |
6456 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg); | 6424 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg); |
6457 } | 6425 } |
6458 | 6426 |
6459 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi
onCallbackInfo<v8::Value>& info) | 6427 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi
onCallbackInfo<v8::Value>& info) |
6460 { | 6428 { |
6461 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6429 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6462 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info); | 6430 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info); |
6463 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6431 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6464 } | 6432 } |
(...skipping 331 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6796 | 6764 |
6797 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) | 6765 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) |
6798 { | 6766 { |
6799 if (UNLIKELY(info.Length() < 1)) { | 6767 if (UNLIKELY(info.Length() < 1)) { |
6800 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodXPathNSResolverArg", "TestObject", 1, info.Length(), info.GetIsolate())
, info.GetIsolate()); | 6768 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodXPathNSResolverArg", "TestObject", 1, info.Length(), info.GetIsolate())
, info.GetIsolate()); |
6801 return; | 6769 return; |
6802 } | 6770 } |
6803 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6771 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6804 RefPtrWillBeRawPtr<XPathNSResolver> xPathNSResolverArg; | 6772 RefPtrWillBeRawPtr<XPathNSResolver> xPathNSResolverArg; |
6805 { | 6773 { |
6806 v8::TryCatch block; | 6774 xPathNSResolverArg = toXPathNSResolver(info[0], info.GetIsolate()); |
6807 V8RethrowTryCatchScope rethrow(block); | |
6808 TONATIVE_VOID_INTERNAL(xPathNSResolverArg, toXPathNSResolver(info[0], in
fo.GetIsolate())); | |
6809 } | 6775 } |
6810 impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release()); | 6776 impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release()); |
6811 } | 6777 } |
6812 | 6778 |
6813 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 6779 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
6814 { | 6780 { |
6815 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6781 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6816 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info); | 6782 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info); |
6817 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6783 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6818 } | 6784 } |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6941 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6907 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6942 TestObjectV8Internal::voidMethodOptionalStringArgMethod(info); | 6908 TestObjectV8Internal::voidMethodOptionalStringArgMethod(info); |
6943 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6909 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6944 } | 6910 } |
6945 | 6911 |
6946 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 6912 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
6947 { | 6913 { |
6948 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6914 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6949 TestInterfaceEmpty* optionalTestInterfaceEmptyArg; | 6915 TestInterfaceEmpty* optionalTestInterfaceEmptyArg; |
6950 { | 6916 { |
6951 v8::TryCatch block; | |
6952 V8RethrowTryCatchScope rethrow(block); | |
6953 if (UNLIKELY(info.Length() <= 0)) { | 6917 if (UNLIKELY(info.Length() <= 0)) { |
6954 impl->voidMethodOptionalTestInterfaceEmptyArg(); | 6918 impl->voidMethodOptionalTestInterfaceEmptyArg(); |
6955 return; | 6919 return; |
6956 } | 6920 } |
6957 TONATIVE_VOID_INTERNAL(optionalTestInterfaceEmptyArg, V8TestInterfaceEmp
ty::toImplWithTypeCheck(info.GetIsolate(), info[0])); | 6921 optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeChec
k(info.GetIsolate(), info[0]); |
6958 } | 6922 } |
6959 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg)
; | 6923 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg)
; |
6960 } | 6924 } |
6961 | 6925 |
6962 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 6926 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
6963 { | 6927 { |
6964 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6928 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6965 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info); | 6929 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info); |
6966 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6930 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6967 } | 6931 } |
(...skipping 155 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7123 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgOptionalTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsola
te()); | 7087 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgOptionalTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsola
te()); |
7124 if (UNLIKELY(info.Length() < 1)) { | 7088 if (UNLIKELY(info.Length() < 1)) { |
7125 setMinimumArityTypeError(exceptionState, 1, info.Length()); | 7089 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
7126 exceptionState.throwIfNeeded(); | 7090 exceptionState.throwIfNeeded(); |
7127 return; | 7091 return; |
7128 } | 7092 } |
7129 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7093 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7130 int longArg; | 7094 int longArg; |
7131 TestInterfaceEmpty* optionalTestInterfaceEmpty; | 7095 TestInterfaceEmpty* optionalTestInterfaceEmpty; |
7132 { | 7096 { |
7133 v8::TryCatch block; | |
7134 V8RethrowTryCatchScope rethrow(block); | |
7135 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7097 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7136 if (UNLIKELY(info.Length() <= 1)) { | 7098 if (UNLIKELY(info.Length() <= 1)) { |
7137 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); | 7099 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); |
7138 return; | 7100 return; |
7139 } | 7101 } |
7140 TONATIVE_VOID_INTERNAL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty:
:toImplWithTypeCheck(info.GetIsolate(), info[1])); | 7102 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(i
nfo.GetIsolate(), info[1]); |
7141 } | 7103 } |
7142 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn
terfaceEmpty); | 7104 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn
terfaceEmpty); |
7143 } | 7105 } |
7144 | 7106 |
7145 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 7107 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
7146 { | 7108 { |
7147 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7109 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7148 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i
nfo); | 7110 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i
nfo); |
7149 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7111 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7150 } | 7112 } |
7151 | 7113 |
7152 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 7114 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
7153 { | 7115 { |
7154 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola
te()); | 7116 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola
te()); |
7155 if (UNLIKELY(info.Length() < 1)) { | 7117 if (UNLIKELY(info.Length() < 1)) { |
7156 setMinimumArityTypeError(exceptionState, 1, info.Length()); | 7118 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
7157 exceptionState.throwIfNeeded(); | 7119 exceptionState.throwIfNeeded(); |
7158 return; | 7120 return; |
7159 } | 7121 } |
7160 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7122 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7161 TestInterfaceEmpty* optionalTestInterfaceEmpty; | 7123 TestInterfaceEmpty* optionalTestInterfaceEmpty; |
7162 int longArg; | 7124 int longArg; |
7163 { | 7125 { |
7164 v8::TryCatch block; | 7126 optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(i
nfo.GetIsolate(), info[0]); |
7165 V8RethrowTryCatchScope rethrow(block); | |
7166 TONATIVE_VOID_INTERNAL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty:
:toImplWithTypeCheck(info.GetIsolate(), info[0])); | |
7167 if (UNLIKELY(info.Length() <= 1)) { | 7127 if (UNLIKELY(info.Length() <= 1)) { |
7168 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInt
erfaceEmpty); | 7128 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInt
erfaceEmpty); |
7169 return; | 7129 return; |
7170 } | 7130 } |
7171 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[1], exceptio
nState), exceptionState); | 7131 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[1], exceptio
nState), exceptionState); |
7172 } | 7132 } |
7173 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm
pty, longArg); | 7133 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm
pty, longArg); |
7174 } | 7134 } |
7175 | 7135 |
7176 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 7136 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7300 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7260 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7301 TestObjectV8Internal::voidMethodDefaultDoubleArgMethod(info); | 7261 TestObjectV8Internal::voidMethodDefaultDoubleArgMethod(info); |
7302 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7262 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7303 } | 7263 } |
7304 | 7264 |
7305 static void voidMethodDefaultTrueBooleanArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 7265 static void voidMethodDefaultTrueBooleanArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
7306 { | 7266 { |
7307 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7267 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7308 bool defaultBooleanArg; | 7268 bool defaultBooleanArg; |
7309 { | 7269 { |
7310 v8::TryCatch block; | |
7311 V8RethrowTryCatchScope rethrow(block); | |
7312 if (!info[0]->IsUndefined()) { | 7270 if (!info[0]->IsUndefined()) { |
7313 TONATIVE_VOID_INTERNAL(defaultBooleanArg, info[0]->BooleanValue()); | 7271 defaultBooleanArg = info[0]->BooleanValue(); |
7314 } else { | 7272 } else { |
7315 defaultBooleanArg = true; | 7273 defaultBooleanArg = true; |
7316 } | 7274 } |
7317 } | 7275 } |
7318 impl->voidMethodDefaultTrueBooleanArg(defaultBooleanArg); | 7276 impl->voidMethodDefaultTrueBooleanArg(defaultBooleanArg); |
7319 } | 7277 } |
7320 | 7278 |
7321 static void voidMethodDefaultTrueBooleanArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 7279 static void voidMethodDefaultTrueBooleanArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
7322 { | 7280 { |
7323 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7281 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7324 TestObjectV8Internal::voidMethodDefaultTrueBooleanArgMethod(info); | 7282 TestObjectV8Internal::voidMethodDefaultTrueBooleanArgMethod(info); |
7325 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7283 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7326 } | 7284 } |
7327 | 7285 |
7328 static void voidMethodDefaultFalseBooleanArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) | 7286 static void voidMethodDefaultFalseBooleanArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) |
7329 { | 7287 { |
7330 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7288 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7331 bool defaultBooleanArg; | 7289 bool defaultBooleanArg; |
7332 { | 7290 { |
7333 v8::TryCatch block; | |
7334 V8RethrowTryCatchScope rethrow(block); | |
7335 if (!info[0]->IsUndefined()) { | 7291 if (!info[0]->IsUndefined()) { |
7336 TONATIVE_VOID_INTERNAL(defaultBooleanArg, info[0]->BooleanValue()); | 7292 defaultBooleanArg = info[0]->BooleanValue(); |
7337 } else { | 7293 } else { |
7338 defaultBooleanArg = false; | 7294 defaultBooleanArg = false; |
7339 } | 7295 } |
7340 } | 7296 } |
7341 impl->voidMethodDefaultFalseBooleanArg(defaultBooleanArg); | 7297 impl->voidMethodDefaultFalseBooleanArg(defaultBooleanArg); |
7342 } | 7298 } |
7343 | 7299 |
7344 static void voidMethodDefaultFalseBooleanArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 7300 static void voidMethodDefaultFalseBooleanArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
7345 { | 7301 { |
7346 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7302 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7389 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7345 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7390 TestObjectV8Internal::voidMethodDefaultNullableStringArgMethod(info); | 7346 TestObjectV8Internal::voidMethodDefaultNullableStringArgMethod(info); |
7391 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7347 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7392 } | 7348 } |
7393 | 7349 |
7394 static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCa
llbackInfo<v8::Value>& info) | 7350 static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCa
llbackInfo<v8::Value>& info) |
7395 { | 7351 { |
7396 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7352 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7397 TestInterfaceImplementation* defaultTestInterfaceArg; | 7353 TestInterfaceImplementation* defaultTestInterfaceArg; |
7398 { | 7354 { |
7399 v8::TryCatch block; | |
7400 V8RethrowTryCatchScope rethrow(block); | |
7401 if (!info[0]->IsUndefined()) { | 7355 if (!info[0]->IsUndefined()) { |
7402 TONATIVE_VOID_INTERNAL(defaultTestInterfaceArg, V8TestInterface::toI
mplWithTypeCheck(info.GetIsolate(), info[0])); | 7356 defaultTestInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.
GetIsolate(), info[0]); |
7403 } else { | 7357 } else { |
7404 defaultTestInterfaceArg = nullptr; | 7358 defaultTestInterfaceArg = nullptr; |
7405 } | 7359 } |
7406 } | 7360 } |
7407 impl->voidMethodDefaultNullableTestInterfaceArg(defaultTestInterfaceArg); | 7361 impl->voidMethodDefaultNullableTestInterfaceArg(defaultTestInterfaceArg); |
7408 } | 7362 } |
7409 | 7363 |
7410 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) | 7364 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) |
7411 { | 7365 { |
7412 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7366 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7484 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 7438 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
7485 { | 7439 { |
7486 if (UNLIKELY(info.Length() < 1)) { | 7440 if (UNLIKELY(info.Length() < 1)) { |
7487 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", 1, i
nfo.Length(), info.GetIsolate()), info.GetIsolate()); | 7441 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", 1, i
nfo.Length(), info.GetIsolate()), info.GetIsolate()); |
7488 return; | 7442 return; |
7489 } | 7443 } |
7490 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7444 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7491 TestInterfaceEmpty* testInterfaceEmptyArg; | 7445 TestInterfaceEmpty* testInterfaceEmptyArg; |
7492 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; | 7446 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; |
7493 { | 7447 { |
7494 v8::TryCatch block; | 7448 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
7495 V8RethrowTryCatchScope rethrow(block); | |
7496 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
7497 for (int i = 1; i < info.Length(); ++i) { | 7449 for (int i = 1; i < info.Length(); ++i) { |
7498 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ | 7450 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ |
7499 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject"
, "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 7451 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject"
, "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); |
7500 return; | 7452 return; |
7501 } | 7453 } |
7502 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); | 7454 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); |
7503 } | 7455 } |
7504 } | 7456 } |
7505 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); | 7457 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); |
7506 } | 7458 } |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7691 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7643 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7692 } | 7644 } |
7693 impl->overloadedMethodC(longArg); | 7645 impl->overloadedMethodC(longArg); |
7694 } | 7646 } |
7695 | 7647 |
7696 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7648 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7697 { | 7649 { |
7698 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7650 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7699 TestInterfaceEmpty* testInterfaceEmptyArg; | 7651 TestInterfaceEmpty* testInterfaceEmptyArg; |
7700 { | 7652 { |
7701 v8::TryCatch block; | 7653 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
7702 V8RethrowTryCatchScope rethrow(block); | |
7703 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
7704 } | 7654 } |
7705 impl->overloadedMethodC(testInterfaceEmptyArg); | 7655 impl->overloadedMethodC(testInterfaceEmptyArg); |
7706 } | 7656 } |
7707 | 7657 |
7708 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7658 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7709 { | 7659 { |
7710 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObject", info.Holder(), info.GetIsolate()); | 7660 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObject", info.Holder(), info.GetIsolate()); |
7711 switch (std::min(1, info.Length())) { | 7661 switch (std::min(1, info.Length())) { |
7712 case 1: | 7662 case 1: |
7713 if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) { | 7663 if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) { |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7797 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7747 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7798 } | 7748 } |
7799 impl->overloadedMethodE(longArg); | 7749 impl->overloadedMethodE(longArg); |
7800 } | 7750 } |
7801 | 7751 |
7802 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7752 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7803 { | 7753 { |
7804 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7754 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7805 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; | 7755 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; |
7806 { | 7756 { |
7807 v8::TryCatch block; | 7757 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(
info.GetIsolate(), info[0]); |
7808 V8RethrowTryCatchScope rethrow(block); | |
7809 TONATIVE_VOID_INTERNAL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty
::toImplWithTypeCheck(info.GetIsolate(), info[0])); | |
7810 } | 7758 } |
7811 impl->overloadedMethodE(testInterfaceEmptyOrNullArg); | 7759 impl->overloadedMethodE(testInterfaceEmptyOrNullArg); |
7812 } | 7760 } |
7813 | 7761 |
7814 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7762 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7815 { | 7763 { |
7816 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodE", "TestObject", info.Holder(), info.GetIsolate()); | 7764 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodE", "TestObject", info.Holder(), info.GetIsolate()); |
7817 switch (std::min(1, info.Length())) { | 7765 switch (std::min(1, info.Length())) { |
7818 case 1: | 7766 case 1: |
7819 if (isUndefinedOrNull(info[0])) { | 7767 if (isUndefinedOrNull(info[0])) { |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7923 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7871 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7924 } | 7872 } |
7925 impl->overloadedMethodG(longArg); | 7873 impl->overloadedMethodG(longArg); |
7926 } | 7874 } |
7927 | 7875 |
7928 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7876 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7929 { | 7877 { |
7930 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7878 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7931 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; | 7879 TestInterfaceEmpty* testInterfaceEmptyOrNullArg; |
7932 { | 7880 { |
7933 v8::TryCatch block; | |
7934 V8RethrowTryCatchScope rethrow(block); | |
7935 if (!info[0]->IsUndefined()) { | 7881 if (!info[0]->IsUndefined()) { |
7936 TONATIVE_VOID_INTERNAL(testInterfaceEmptyOrNullArg, V8TestInterfaceE
mpty::toImplWithTypeCheck(info.GetIsolate(), info[0])); | 7882 testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCh
eck(info.GetIsolate(), info[0]); |
7937 } else { | 7883 } else { |
7938 testInterfaceEmptyOrNullArg = nullptr; | 7884 testInterfaceEmptyOrNullArg = nullptr; |
7939 } | 7885 } |
7940 } | 7886 } |
7941 impl->overloadedMethodG(testInterfaceEmptyOrNullArg); | 7887 impl->overloadedMethodG(testInterfaceEmptyOrNullArg); |
7942 } | 7888 } |
7943 | 7889 |
7944 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7890 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7945 { | 7891 { |
7946 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodG", "TestObject", info.Holder(), info.GetIsolate()); | 7892 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodG", "TestObject", info.Holder(), info.GetIsolate()); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7983 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7929 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7984 TestObjectV8Internal::overloadedMethodGMethod(info); | 7930 TestObjectV8Internal::overloadedMethodGMethod(info); |
7985 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7931 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7986 } | 7932 } |
7987 | 7933 |
7988 static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7934 static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7989 { | 7935 { |
7990 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7936 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7991 TestInterfaceImplementation* testInterfaceArg; | 7937 TestInterfaceImplementation* testInterfaceArg; |
7992 { | 7938 { |
7993 v8::TryCatch block; | 7939 testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(
), info[0]); |
7994 V8RethrowTryCatchScope rethrow(block); | |
7995 TONATIVE_VOID_INTERNAL(testInterfaceArg, V8TestInterface::toImplWithType
Check(info.GetIsolate(), info[0])); | |
7996 } | 7940 } |
7997 impl->overloadedMethodH(testInterfaceArg); | 7941 impl->overloadedMethodH(testInterfaceArg); |
7998 } | 7942 } |
7999 | 7943 |
8000 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7944 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
8001 { | 7945 { |
8002 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7946 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8003 TestInterfaceEmpty* testInterfaceEmptyArg; | 7947 TestInterfaceEmpty* testInterfaceEmptyArg; |
8004 { | 7948 { |
8005 v8::TryCatch block; | 7949 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
8006 V8RethrowTryCatchScope rethrow(block); | |
8007 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
8008 } | 7950 } |
8009 impl->overloadedMethodH(testInterfaceEmptyArg); | 7951 impl->overloadedMethodH(testInterfaceEmptyArg); |
8010 } | 7952 } |
8011 | 7953 |
8012 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7954 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
8013 { | 7955 { |
8014 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodH", "TestObject", info.Holder(), info.GetIsolate()); | 7956 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodH", "TestObject", info.Holder(), info.GetIsolate()); |
8015 switch (std::min(1, info.Length())) { | 7957 switch (std::min(1, info.Length())) { |
8016 case 1: | 7958 case 1: |
8017 if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) { | 7959 if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) { |
(...skipping 332 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8350 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8292 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8351 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info); | 8293 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info); |
8352 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8294 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8353 } | 8295 } |
8354 | 8296 |
8355 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 8297 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
8356 { | 8298 { |
8357 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 8299 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8358 TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg; | 8300 TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg; |
8359 { | 8301 { |
8360 v8::TryCatch block; | 8302 defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWith
TypeCheck(info.GetIsolate(), info[0]); |
8361 V8RethrowTryCatchScope rethrow(block); | |
8362 TONATIVE_VOID_INTERNAL(defaultUndefinedTestInterfaceEmptyArg, V8TestInte
rfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0])); | |
8363 } | 8303 } |
8364 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn
terfaceEmptyArg); | 8304 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn
terfaceEmptyArg); |
8365 } | 8305 } |
8366 | 8306 |
8367 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 8307 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
8368 { | 8308 { |
8369 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8309 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8370 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(
info); | 8310 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(
info); |
8371 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8311 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8372 } | 8312 } |
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8582 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8522 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8583 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(inf
o); | 8523 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(inf
o); |
8584 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8524 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8585 } | 8525 } |
8586 | 8526 |
8587 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod
(const v8::FunctionCallbackInfo<v8::Value>& info) | 8527 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod
(const v8::FunctionCallbackInfo<v8::Value>& info) |
8588 { | 8528 { |
8589 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 8529 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8590 bool optionalBooleanArg; | 8530 bool optionalBooleanArg; |
8591 { | 8531 { |
8592 v8::TryCatch block; | |
8593 V8RethrowTryCatchScope rethrow(block); | |
8594 if (UNLIKELY(info.Length() <= 0)) { | 8532 if (UNLIKELY(info.Length() <= 0)) { |
8595 ScriptState* scriptState = ScriptState::current(info.GetIsolate()); | 8533 ScriptState* scriptState = ScriptState::current(info.GetIsolate()); |
8596 RefPtrWillBeRawPtr<ScriptArguments> scriptArguments(createScriptArgu
ments(scriptState, info, 1)); | 8534 RefPtrWillBeRawPtr<ScriptArguments> scriptArguments(createScriptArgu
ments(scriptState, info, 1)); |
8597 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg
(scriptState, scriptArguments.release()); | 8535 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg
(scriptState, scriptArguments.release()); |
8598 return; | 8536 return; |
8599 } | 8537 } |
8600 TONATIVE_VOID_INTERNAL(optionalBooleanArg, info[0]->BooleanValue()); | 8538 optionalBooleanArg = info[0]->BooleanValue(); |
8601 } | 8539 } |
8602 ScriptState* scriptState = ScriptState::current(info.GetIsolate()); | 8540 ScriptState* scriptState = ScriptState::current(info.GetIsolate()); |
8603 RefPtrWillBeRawPtr<ScriptArguments> scriptArguments(createScriptArguments(sc
riptState, info, 1)); | 8541 RefPtrWillBeRawPtr<ScriptArguments> scriptArguments(createScriptArguments(sc
riptState, info, 1)); |
8604 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(scriptS
tate, scriptArguments.release(), optionalBooleanArg); | 8542 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(scriptS
tate, scriptArguments.release(), optionalBooleanArg); |
8605 } | 8543 } |
8606 | 8544 |
8607 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod
Callback(const v8::FunctionCallbackInfo<v8::Value>& info) | 8545 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod
Callback(const v8::FunctionCallbackInfo<v8::Value>& info) |
8608 { | 8546 { |
8609 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8547 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8610 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBo
oleanArgMethod(info); | 8548 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBo
oleanArgMethod(info); |
(...skipping 572 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9183 | 9121 |
9184 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 9122 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
9185 { | 9123 { |
9186 if (UNLIKELY(info.Length() < 1)) { | 9124 if (UNLIKELY(info.Length() < 1)) { |
9187 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); | 9125 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); |
9188 return; | 9126 return; |
9189 } | 9127 } |
9190 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9128 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9191 TestInterfaceEmpty* testInterfaceEmptyArg; | 9129 TestInterfaceEmpty* testInterfaceEmptyArg; |
9192 { | 9130 { |
9193 v8::TryCatch block; | 9131 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
9194 V8RethrowTryCatchScope rethrow(block); | |
9195 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
9196 } | 9132 } |
9197 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; | 9133 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; |
9198 } | 9134 } |
9199 | 9135 |
9200 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9136 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
9201 { | 9137 { |
9202 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9138 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9203 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(
info); | 9139 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(
info); |
9204 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9140 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9205 } | 9141 } |
9206 | 9142 |
9207 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) | 9143 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) |
9208 { | 9144 { |
9209 if (UNLIKELY(info.Length() < 1)) { | 9145 if (UNLIKELY(info.Length() < 1)) { |
9210 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); | 9146 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("p
erWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); |
9211 return; | 9147 return; |
9212 } | 9148 } |
9213 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9149 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9214 TestInterfaceEmpty* testInterfaceEmptyArg; | 9150 TestInterfaceEmpty* testInterfaceEmptyArg; |
9215 { | 9151 { |
9216 v8::TryCatch block; | 9152 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
9217 V8RethrowTryCatchScope rethrow(block); | |
9218 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | |
9219 } | 9153 } |
9220 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; | 9154 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg)
; |
9221 } | 9155 } |
9222 | 9156 |
9223 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) | 9157 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) |
9224 { | 9158 { |
9225 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9159 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9226 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF
orMainWorld(info); | 9160 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF
orMainWorld(info); |
9227 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9161 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9228 } | 9162 } |
(...skipping 345 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9574 TOSTRING_VOID_INTERNAL(stringArg, info[0]); | 9508 TOSTRING_VOID_INTERNAL(stringArg, info[0]); |
9575 } | 9509 } |
9576 impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg); | 9510 impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg); |
9577 } | 9511 } |
9578 | 9512 |
9579 static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::Functio
nCallbackInfo<v8::Value>& info) | 9513 static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::Functio
nCallbackInfo<v8::Value>& info) |
9580 { | 9514 { |
9581 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9515 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9582 TestInterfaceImplementation* testInterface; | 9516 TestInterfaceImplementation* testInterface; |
9583 { | 9517 { |
9584 v8::TryCatch block; | 9518 testInterface = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(),
info[0]); |
9585 V8RethrowTryCatchScope rethrow(block); | |
9586 TONATIVE_VOID_INTERNAL(testInterface, V8TestInterface::toImplWithTypeChe
ck(info.GetIsolate(), info[0])); | |
9587 } | 9519 } |
9588 impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface); | 9520 impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface); |
9589 } | 9521 } |
9590 | 9522 |
9591 static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::Functio
nCallbackInfo<v8::Value>& info) | 9523 static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::Functio
nCallbackInfo<v8::Value>& info) |
9592 { | 9524 { |
9593 ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRu
ntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate(
)); | 9525 ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRu
ntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate(
)); |
9594 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9526 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9595 int longArg; | 9527 int longArg; |
9596 { | 9528 { |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9721 | 9653 |
9722 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) | 9654 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) |
9723 { | 9655 { |
9724 if (UNLIKELY(info.Length() < 1)) { | 9656 if (UNLIKELY(info.Length() < 1)) { |
9725 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("t
ypeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); | 9657 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("t
ypeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Leng
th(), info.GetIsolate()), info.GetIsolate()); |
9726 return; | 9658 return; |
9727 } | 9659 } |
9728 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9660 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9729 TestInterfaceEmpty* testInterfaceEmptyArg; | 9661 TestInterfaceEmpty* testInterfaceEmptyArg; |
9730 { | 9662 { |
9731 v8::TryCatch block; | |
9732 V8RethrowTryCatchScope rethrow(block); | |
9733 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], inf
o.GetIsolate())) { | 9663 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], inf
o.GetIsolate())) { |
9734 V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute(
"typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter
1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 9664 V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute(
"typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter
1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); |
9735 return; | 9665 return; |
9736 } | 9666 } |
9737 TONATIVE_VOID_INTERNAL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toIm
plWithTypeCheck(info.GetIsolate(), info[0])); | 9667 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
9738 } | 9668 } |
9739 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt
yArg); | 9669 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt
yArg); |
9740 } | 9670 } |
9741 | 9671 |
9742 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9672 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
9743 { | 9673 { |
9744 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9674 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9745 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); | 9675 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); |
9746 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9676 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9747 } | 9677 } |
(...skipping 242 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9990 | 9920 |
9991 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) | 9921 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(const v8:
:FunctionCallbackInfo<v8::Value>& info) |
9992 { | 9922 { |
9993 if (UNLIKELY(info.Length() < 1)) { | 9923 if (UNLIKELY(info.Length() < 1)) { |
9994 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()); |
9995 return; | 9925 return; |
9996 } | 9926 } |
9997 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9927 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9998 Node* value; | 9928 Node* value; |
9999 { | 9929 { |
10000 v8::TryCatch block; | 9930 value = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]); |
10001 V8RethrowTryCatchScope rethrow(block); | |
10002 TONATIVE_VOID_INTERNAL(value, V8Node::toImplWithTypeCheck(info.GetIsolat
e(), info[0])); | |
10003 } | 9931 } |
10004 RefPtrWillBeRawPtr<Node> result = nullptr; | 9932 RefPtrWillBeRawPtr<Node> result = nullptr; |
10005 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)) |
10006 return; | 9934 return; |
10007 v8SetReturnValue(info, result.release()); | 9935 v8SetReturnValue(info, result.release()); |
10008 } | 9936 } |
10009 | 9937 |
10010 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9938 static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
10011 { | 9939 { |
10012 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9940 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
10013 TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMe
thod(info); | 9941 TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMe
thod(info); |
10014 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9942 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
10015 } | 9943 } |
10016 | 9944 |
10017 static void nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9945 static void nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) |
10018 { | 9946 { |
10019 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()); |
10020 if (UNLIKELY(info.Length() < 5)) { | 9948 if (UNLIKELY(info.Length() < 5)) { |
10021 setMinimumArityTypeError(exceptionState, 5, info.Length()); | 9949 setMinimumArityTypeError(exceptionState, 5, info.Length()); |
10022 exceptionState.throwIfNeeded(); | 9950 exceptionState.throwIfNeeded(); |
10023 return; | 9951 return; |
10024 } | 9952 } |
10025 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9953 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
10026 Document* document; | 9954 Document* document; |
10027 Node* node; | 9955 Node* node; |
10028 int value1; | 9956 int value1; |
10029 double value2; | 9957 double value2; |
10030 V8StringResource<> string; | 9958 V8StringResource<> string; |
10031 { | 9959 { |
10032 v8::TryCatch block; | 9960 document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]); |
10033 V8RethrowTryCatchScope rethrow(block); | 9961 node = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]); |
10034 TONATIVE_VOID_INTERNAL(document, V8Document::toImplWithTypeCheck(info.Ge
tIsolate(), info[0])); | |
10035 TONATIVE_VOID_INTERNAL(node, V8Node::toImplWithTypeCheck(info.GetIsolate
(), info[1])); | |
10036 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value1, toInt16(info[2], exception
State), exceptionState); | 9962 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value1, toInt16(info[2], exception
State), exceptionState); |
10037 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value2, toDouble(info[3], exceptio
nState), exceptionState); | 9963 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value2, toDouble(info[3], exceptio
nState), exceptionState); |
10038 TOSTRING_VOID_INTERNAL(string, info[4]); | 9964 TOSTRING_VOID_INTERNAL(string, info[4]); |
10039 } | 9965 } |
10040 RefPtrWillBeRawPtr<Node> result = nullptr; | 9966 RefPtrWillBeRawPtr<Node> result = nullptr; |
10041 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)) |
10042 return; | 9968 return; |
10043 v8SetReturnValue(info, result.release()); | 9969 v8SetReturnValue(info, result.release()); |
10044 } | 9970 } |
10045 | 9971 |
(...skipping 755 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10801 v8::Handle<v8::Value> valueHandle = toV8(value, scriptState->context()->Glob
al(), scriptState->isolate()); | 10727 v8::Handle<v8::Value> valueHandle = toV8(value, scriptState->context()->Glob
al(), scriptState->isolate()); |
10802 v8::Handle<v8::Value> argv[] = { valueHandle }; | 10728 v8::Handle<v8::Value> argv[] = { valueHandle }; |
10803 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithNodeArgumentImplementedInPrivateScript", "TestObject", scriptState->context()
->Global(), scriptState->isolate()); | 10729 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithNodeArgumentImplementedInPrivateScript", "TestObject", scriptState->context()
->Global(), scriptState->isolate()); |
10804 v8::TryCatch block; | 10730 v8::TryCatch block; |
10805 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, "TestObject", "nodeMethodWithNodeArgumentImplementedInPrivateScript", holder,
1, argv); | 10731 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, "TestObject", "nodeMethodWithNodeArgumentImplementedInPrivateScript", holder,
1, argv); |
10806 if (block.HasCaught()) { | 10732 if (block.HasCaught()) { |
10807 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); | 10733 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); |
10808 block.ReThrow(); | 10734 block.ReThrow(); |
10809 return false; | 10735 return false; |
10810 } | 10736 } |
10811 TONATIVE_DEFAULT(Node*, cppValue, V8Node::toImplWithTypeCheck(scriptState->i
solate(), v8Value), false); | 10737 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); |
10812 RELEASE_ASSERT(!exceptionState.hadException()); | 10738 RELEASE_ASSERT(!exceptionState.hadException()); |
10813 *result = cppValue; | 10739 *result = cppValue; |
10814 return true; | 10740 return true; |
10815 } | 10741 } |
10816 | 10742 |
10817 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) | 10743 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) |
10818 { | 10744 { |
10819 if (!frame) | 10745 if (!frame) |
10820 return false; | 10746 return false; |
10821 v8::HandleScope handleScope(toIsolate(frame)); | 10747 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 15 matching lines...) Expand all Loading... |
10837 v8::Handle<v8::Value> stringHandle = v8String(scriptState->isolate(), string
); | 10763 v8::Handle<v8::Value> stringHandle = v8String(scriptState->isolate(), string
); |
10838 v8::Handle<v8::Value> argv[] = { documentHandle, nodeHandle, value1Handle, v
alue2Handle, stringHandle }; | 10764 v8::Handle<v8::Value> argv[] = { documentHandle, nodeHandle, value1Handle, v
alue2Handle, stringHandle }; |
10839 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", scriptState->conte
xt()->Global(), scriptState->isolate()); | 10765 ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeMethodW
ithVariousArgumentsImplementedInPrivateScript", "TestObject", scriptState->conte
xt()->Global(), scriptState->isolate()); |
10840 v8::TryCatch block; | 10766 v8::TryCatch block; |
10841 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, "TestObject", "nodeMethodWithVariousArgumentsImplementedInPrivateScript", hol
der, 5, argv); | 10767 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptStat
e, "TestObject", "nodeMethodWithVariousArgumentsImplementedInPrivateScript", hol
der, 5, argv); |
10842 if (block.HasCaught()) { | 10768 if (block.HasCaught()) { |
10843 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); | 10769 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); |
10844 block.ReThrow(); | 10770 block.ReThrow(); |
10845 return false; | 10771 return false; |
10846 } | 10772 } |
10847 TONATIVE_DEFAULT(Node*, cppValue, V8Node::toImplWithTypeCheck(scriptState->i
solate(), v8Value), false); | 10773 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); |
10848 RELEASE_ASSERT(!exceptionState.hadException()); | 10774 RELEASE_ASSERT(!exceptionState.hadException()); |
10849 *result = cppValue; | 10775 *result = cppValue; |
10850 return true; | 10776 return true; |
10851 } | 10777 } |
10852 | 10778 |
10853 bool V8TestObject::PrivateScript::methodForPrivateScriptOnlyMethod(LocalFrame* f
rame, TestObject* holderImpl, int value1, int value2, int* result) | 10779 bool V8TestObject::PrivateScript::methodForPrivateScriptOnlyMethod(LocalFrame* f
rame, TestObject* holderImpl, int value1, int value2, int* result) |
10854 { | 10780 { |
10855 if (!frame) | 10781 if (!frame) |
10856 return false; | 10782 return false; |
10857 v8::HandleScope handleScope(toIsolate(frame)); | 10783 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 186 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11044 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); | 10970 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); |
11045 | 10971 |
11046 ExceptionState exceptionState(ExceptionState::GetterContext, "nodeAttribute"
, "TestObject", scriptState->context()->Global(), scriptState->isolate()); | 10972 ExceptionState exceptionState(ExceptionState::GetterContext, "nodeAttribute"
, "TestObject", scriptState->context()->Global(), scriptState->isolate()); |
11047 v8::TryCatch block; | 10973 v8::TryCatch block; |
11048 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMAttributeGetter(s
criptState, "TestObject", "nodeAttribute", holder); | 10974 v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMAttributeGetter(s
criptState, "TestObject", "nodeAttribute", holder); |
11049 if (block.HasCaught()) { | 10975 if (block.HasCaught()) { |
11050 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); | 10976 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); |
11051 block.ReThrow(); | 10977 block.ReThrow(); |
11052 return false; | 10978 return false; |
11053 } | 10979 } |
11054 TONATIVE_DEFAULT(Node*, cppValue, V8Node::toImplWithTypeCheck(scriptState->i
solate(), v8Value), false); | 10980 Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value
); |
11055 RELEASE_ASSERT(!exceptionState.hadException()); | 10981 RELEASE_ASSERT(!exceptionState.hadException()); |
11056 *result = cppValue; | 10982 *result = cppValue; |
11057 return true; | 10983 return true; |
11058 } | 10984 } |
11059 | 10985 |
11060 bool V8TestObject::PrivateScript::nodeAttributeAttributeSetter(LocalFrame* frame
, TestObject* holderImpl, PassRefPtrWillBeRawPtr<Node> cppValue) | 10986 bool V8TestObject::PrivateScript::nodeAttributeAttributeSetter(LocalFrame* frame
, TestObject* holderImpl, PassRefPtrWillBeRawPtr<Node> cppValue) |
11061 { | 10987 { |
11062 if (!frame) | 10988 if (!frame) |
11063 return false; | 10989 return false; |
11064 v8::HandleScope handleScope(toIsolate(frame)); | 10990 v8::HandleScope handleScope(toIsolate(frame)); |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11192 PrivateScriptRunner::runDOMAttributeSetter(scriptState, "TestObject", "enumF
orPrivateScript", holder, v8String(scriptState->isolate(), cppValue)); | 11118 PrivateScriptRunner::runDOMAttributeSetter(scriptState, "TestObject", "enumF
orPrivateScript", holder, v8String(scriptState->isolate(), cppValue)); |
11193 if (block.HasCaught()) { | 11119 if (block.HasCaught()) { |
11194 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); | 11120 PrivateScriptRunner::rethrowExceptionInPrivateScript(scriptState->isolat
e(), exceptionState, block); |
11195 block.ReThrow(); | 11121 block.ReThrow(); |
11196 return false; | 11122 return false; |
11197 } | 11123 } |
11198 return true; | 11124 return true; |
11199 } | 11125 } |
11200 | 11126 |
11201 } // namespace blink | 11127 } // namespace blink |
OLD | NEW |