Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(681)

Side by Side Diff: Source/bindings/tests/results/V8TestObject.cpp

Issue 265293004: Create fewer local v8::TryCatch objects in generated bindings code (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 "HTMLNames.h" 10 #include "HTMLNames.h"
(...skipping 4740 matching lines...) Expand 10 before | Expand all | Expand 10 after
4751 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4751 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4752 } 4752 }
4753 4753
4754 static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 4754 static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
4755 { 4755 {
4756 if (UNLIKELY(info.Length() < 1)) { 4756 if (UNLIKELY(info.Length() < 1)) {
4757 throwArityTypeErrorForMethod("voidMethodDateArg", "TestObject", 1, info. Length(), info.GetIsolate()); 4757 throwArityTypeErrorForMethod("voidMethodDateArg", "TestObject", 1, info. Length(), info.GetIsolate());
4758 return; 4758 return;
4759 } 4759 }
4760 TestObject* impl = V8TestObject::toNative(info.Holder()); 4760 TestObject* impl = V8TestObject::toNative(info.Holder());
4761 TONATIVE_VOID(double, dateArg, toCoreDate(info[0])); 4761 double dateArg;
4762 {
4763 v8::TryCatch block;
4764 TONATIVE_VOID_NO_DECL(dateArg, toCoreDate(info[0]));
4765 }
4762 impl->voidMethodDateArg(dateArg); 4766 impl->voidMethodDateArg(dateArg);
4763 } 4767 }
4764 4768
4765 static void voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info) 4769 static void voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info)
4766 { 4770 {
4767 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4771 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4768 TestObjectV8Internal::voidMethodDateArgMethod(info); 4772 TestObjectV8Internal::voidMethodDateArgMethod(info);
4769 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4773 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4770 } 4774 }
4771 4775
4772 static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 4776 static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4773 { 4777 {
4774 if (UNLIKELY(info.Length() < 1)) { 4778 if (UNLIKELY(info.Length() < 1)) {
4775 throwArityTypeErrorForMethod("voidMethodStringArg", "TestObject", 1, inf o.Length(), info.GetIsolate()); 4779 throwArityTypeErrorForMethod("voidMethodStringArg", "TestObject", 1, inf o.Length(), info.GetIsolate());
4776 return; 4780 return;
4777 } 4781 }
4778 TestObject* impl = V8TestObject::toNative(info.Holder()); 4782 TestObject* impl = V8TestObject::toNative(info.Holder());
4779 TOSTRING_VOID(V8StringResource<>, stringArg, info[0]); 4783 V8StringResource<> stringArg;
4784 {
4785 v8::TryCatch block;
4786 TOSTRING_VOID_NO_DECL(stringArg, info[0]);
4787 }
4780 impl->voidMethodStringArg(stringArg); 4788 impl->voidMethodStringArg(stringArg);
4781 } 4789 }
4782 4790
4783 static void voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8: :Value>& info) 4791 static void voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8: :Value>& info)
4784 { 4792 {
4785 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4793 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4786 TestObjectV8Internal::voidMethodStringArgMethod(info); 4794 TestObjectV8Internal::voidMethodStringArgMethod(info);
4787 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4795 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4788 } 4796 }
4789 4797
4790 static void voidMethodDOMTimeStampArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 4798 static void voidMethodDOMTimeStampArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
4791 { 4799 {
4792 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD OMTimeStampArg", "TestObject", info.Holder(), info.GetIsolate()); 4800 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD OMTimeStampArg", "TestObject", info.Holder(), info.GetIsolate());
4793 if (UNLIKELY(info.Length() < 1)) { 4801 if (UNLIKELY(info.Length() < 1)) {
4794 throwArityTypeError(exceptionState, 1, info.Length()); 4802 throwArityTypeError(exceptionState, 1, info.Length());
4795 return; 4803 return;
4796 } 4804 }
4797 TestObject* impl = V8TestObject::toNative(info.Holder()); 4805 TestObject* impl = V8TestObject::toNative(info.Holder());
4798 TONATIVE_VOID_EXCEPTIONSTATE(unsigned long long, domTimeStampArg, toUInt64(i nfo[0], exceptionState), exceptionState); 4806 unsigned long long domTimeStampArg;
4807 {
4808 v8::TryCatch block;
4809 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(domTimeStampArg, toUInt64(info[0], exceptionState), exceptionState);
4810 }
4799 impl->voidMethodDOMTimeStampArg(domTimeStampArg); 4811 impl->voidMethodDOMTimeStampArg(domTimeStampArg);
4800 } 4812 }
4801 4813
4802 static void voidMethodDOMTimeStampArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 4814 static void voidMethodDOMTimeStampArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
4803 { 4815 {
4804 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4816 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4805 TestObjectV8Internal::voidMethodDOMTimeStampArgMethod(info); 4817 TestObjectV8Internal::voidMethodDOMTimeStampArgMethod(info);
4806 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4818 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4807 } 4819 }
4808 4820
4809 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info) 4821 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info)
4810 { 4822 {
4811 if (UNLIKELY(info.Length() < 1)) { 4823 if (UNLIKELY(info.Length() < 1)) {
4812 throwArityTypeErrorForMethod("voidMethodBooleanArg", "TestObject", 1, in fo.Length(), info.GetIsolate()); 4824 throwArityTypeErrorForMethod("voidMethodBooleanArg", "TestObject", 1, in fo.Length(), info.GetIsolate());
4813 return; 4825 return;
4814 } 4826 }
4815 TestObject* impl = V8TestObject::toNative(info.Holder()); 4827 TestObject* impl = V8TestObject::toNative(info.Holder());
4816 TONATIVE_VOID(bool, booleanArg, info[0]->BooleanValue()); 4828 bool booleanArg;
4829 {
4830 v8::TryCatch block;
4831 TONATIVE_VOID_NO_DECL(booleanArg, info[0]->BooleanValue());
4832 }
4817 impl->voidMethodBooleanArg(booleanArg); 4833 impl->voidMethodBooleanArg(booleanArg);
4818 } 4834 }
4819 4835
4820 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info) 4836 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info)
4821 { 4837 {
4822 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4838 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4823 TestObjectV8Internal::voidMethodBooleanArgMethod(info); 4839 TestObjectV8Internal::voidMethodBooleanArgMethod(info);
4824 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4840 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4825 } 4841 }
4826 4842
4827 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 4843 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
4828 { 4844 {
4829 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodB yteArg", "TestObject", info.Holder(), info.GetIsolate()); 4845 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodB yteArg", "TestObject", info.Holder(), info.GetIsolate());
4830 if (UNLIKELY(info.Length() < 1)) { 4846 if (UNLIKELY(info.Length() < 1)) {
4831 throwArityTypeError(exceptionState, 1, info.Length()); 4847 throwArityTypeError(exceptionState, 1, info.Length());
4832 return; 4848 return;
4833 } 4849 }
4834 TestObject* impl = V8TestObject::toNative(info.Holder()); 4850 TestObject* impl = V8TestObject::toNative(info.Holder());
4835 TONATIVE_VOID_EXCEPTIONSTATE(int, byteArg, toInt8(info[0], exceptionState), exceptionState); 4851 int byteArg;
4852 {
4853 v8::TryCatch block;
4854 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(byteArg, toInt8(info[0], exceptionS tate), exceptionState);
4855 }
4836 impl->voidMethodByteArg(byteArg); 4856 impl->voidMethodByteArg(byteArg);
4837 } 4857 }
4838 4858
4839 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info) 4859 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info)
4840 { 4860 {
4841 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4861 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4842 TestObjectV8Internal::voidMethodByteArgMethod(info); 4862 TestObjectV8Internal::voidMethodByteArgMethod(info);
4843 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4863 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4844 } 4864 }
4845 4865
4846 static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 4866 static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4847 { 4867 {
4848 if (UNLIKELY(info.Length() < 1)) { 4868 if (UNLIKELY(info.Length() < 1)) {
4849 throwArityTypeErrorForMethod("voidMethodDoubleArg", "TestObject", 1, inf o.Length(), info.GetIsolate()); 4869 throwArityTypeErrorForMethod("voidMethodDoubleArg", "TestObject", 1, inf o.Length(), info.GetIsolate());
4850 return; 4870 return;
4851 } 4871 }
4852 TestObject* impl = V8TestObject::toNative(info.Holder()); 4872 TestObject* impl = V8TestObject::toNative(info.Holder());
4853 TONATIVE_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue()) ); 4873 double doubleArg;
4874 {
4875 v8::TryCatch block;
4876 TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[0]->NumberValu e()));
4877 }
4854 impl->voidMethodDoubleArg(doubleArg); 4878 impl->voidMethodDoubleArg(doubleArg);
4855 } 4879 }
4856 4880
4857 static void voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8: :Value>& info) 4881 static void voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8: :Value>& info)
4858 { 4882 {
4859 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4883 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4860 TestObjectV8Internal::voidMethodDoubleArgMethod(info); 4884 TestObjectV8Internal::voidMethodDoubleArgMethod(info);
4861 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4885 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4862 } 4886 }
4863 4887
4864 static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 4888 static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4865 { 4889 {
4866 if (UNLIKELY(info.Length() < 1)) { 4890 if (UNLIKELY(info.Length() < 1)) {
4867 throwArityTypeErrorForMethod("voidMethodFloatArg", "TestObject", 1, info .Length(), info.GetIsolate()); 4891 throwArityTypeErrorForMethod("voidMethodFloatArg", "TestObject", 1, info .Length(), info.GetIsolate());
4868 return; 4892 return;
4869 } 4893 }
4870 TestObject* impl = V8TestObject::toNative(info.Holder()); 4894 TestObject* impl = V8TestObject::toNative(info.Holder());
4871 TONATIVE_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue())); 4895 float floatArg;
4896 {
4897 v8::TryCatch block;
4898 TONATIVE_VOID_NO_DECL(floatArg, static_cast<float>(info[0]->NumberValue( )));
4899 }
4872 impl->voidMethodFloatArg(floatArg); 4900 impl->voidMethodFloatArg(floatArg);
4873 } 4901 }
4874 4902
4875 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info) 4903 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info)
4876 { 4904 {
4877 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4905 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4878 TestObjectV8Internal::voidMethodFloatArgMethod(info); 4906 TestObjectV8Internal::voidMethodFloatArgMethod(info);
4879 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4907 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4880 } 4908 }
4881 4909
4882 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 4910 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
4883 { 4911 {
4884 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArg", "TestObject", info.Holder(), info.GetIsolate()); 4912 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArg", "TestObject", info.Holder(), info.GetIsolate());
4885 if (UNLIKELY(info.Length() < 1)) { 4913 if (UNLIKELY(info.Length() < 1)) {
4886 throwArityTypeError(exceptionState, 1, info.Length()); 4914 throwArityTypeError(exceptionState, 1, info.Length());
4887 return; 4915 return;
4888 } 4916 }
4889 TestObject* impl = V8TestObject::toNative(info.Holder()); 4917 TestObject* impl = V8TestObject::toNative(info.Holder());
4890 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 4918 int longArg;
4919 {
4920 v8::TryCatch block;
4921 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
4922 }
4891 impl->voidMethodLongArg(longArg); 4923 impl->voidMethodLongArg(longArg);
4892 } 4924 }
4893 4925
4894 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info) 4926 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info)
4895 { 4927 {
4896 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4928 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4897 TestObjectV8Internal::voidMethodLongArgMethod(info); 4929 TestObjectV8Internal::voidMethodLongArgMethod(info);
4898 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4930 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4899 } 4931 }
4900 4932
4901 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info) 4933 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info)
4902 { 4934 {
4903 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongLongArg", "TestObject", info.Holder(), info.GetIsolate()); 4935 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongLongArg", "TestObject", info.Holder(), info.GetIsolate());
4904 if (UNLIKELY(info.Length() < 1)) { 4936 if (UNLIKELY(info.Length() < 1)) {
4905 throwArityTypeError(exceptionState, 1, info.Length()); 4937 throwArityTypeError(exceptionState, 1, info.Length());
4906 return; 4938 return;
4907 } 4939 }
4908 TestObject* impl = V8TestObject::toNative(info.Holder()); 4940 TestObject* impl = V8TestObject::toNative(info.Holder());
4909 TONATIVE_VOID_EXCEPTIONSTATE(long long, longLongArg, toInt64(info[0], except ionState), exceptionState); 4941 long long longLongArg;
4942 {
4943 v8::TryCatch block;
4944 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longLongArg, toInt64(info[0], excep tionState), exceptionState);
4945 }
4910 impl->voidMethodLongLongArg(longLongArg); 4946 impl->voidMethodLongLongArg(longLongArg);
4911 } 4947 }
4912 4948
4913 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info) 4949 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info)
4914 { 4950 {
4915 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4951 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4916 TestObjectV8Internal::voidMethodLongLongArgMethod(info); 4952 TestObjectV8Internal::voidMethodLongLongArgMethod(info);
4917 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4953 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4918 } 4954 }
4919 4955
4920 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 4956 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4921 { 4957 {
4922 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO ctetArg", "TestObject", info.Holder(), info.GetIsolate()); 4958 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO ctetArg", "TestObject", info.Holder(), info.GetIsolate());
4923 if (UNLIKELY(info.Length() < 1)) { 4959 if (UNLIKELY(info.Length() < 1)) {
4924 throwArityTypeError(exceptionState, 1, info.Length()); 4960 throwArityTypeError(exceptionState, 1, info.Length());
4925 return; 4961 return;
4926 } 4962 }
4927 TestObject* impl = V8TestObject::toNative(info.Holder()); 4963 TestObject* impl = V8TestObject::toNative(info.Holder());
4928 TONATIVE_VOID_EXCEPTIONSTATE(unsigned, octetArg, toUInt8(info[0], exceptionS tate), exceptionState); 4964 unsigned octetArg;
4965 {
4966 v8::TryCatch block;
4967 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(octetArg, toUInt8(info[0], exceptio nState), exceptionState);
4968 }
4929 impl->voidMethodOctetArg(octetArg); 4969 impl->voidMethodOctetArg(octetArg);
4930 } 4970 }
4931 4971
4932 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info) 4972 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info)
4933 { 4973 {
4934 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4974 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4935 TestObjectV8Internal::voidMethodOctetArgMethod(info); 4975 TestObjectV8Internal::voidMethodOctetArgMethod(info);
4936 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4976 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4937 } 4977 }
4938 4978
4939 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 4979 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4940 { 4980 {
4941 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS hortArg", "TestObject", info.Holder(), info.GetIsolate()); 4981 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS hortArg", "TestObject", info.Holder(), info.GetIsolate());
4942 if (UNLIKELY(info.Length() < 1)) { 4982 if (UNLIKELY(info.Length() < 1)) {
4943 throwArityTypeError(exceptionState, 1, info.Length()); 4983 throwArityTypeError(exceptionState, 1, info.Length());
4944 return; 4984 return;
4945 } 4985 }
4946 TestObject* impl = V8TestObject::toNative(info.Holder()); 4986 TestObject* impl = V8TestObject::toNative(info.Holder());
4947 TONATIVE_VOID_EXCEPTIONSTATE(int, shortArg, toInt16(info[0], exceptionState) , exceptionState); 4987 int shortArg;
4988 {
4989 v8::TryCatch block;
4990 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(shortArg, toInt16(info[0], exceptio nState), exceptionState);
4991 }
4948 impl->voidMethodShortArg(shortArg); 4992 impl->voidMethodShortArg(shortArg);
4949 } 4993 }
4950 4994
4951 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info) 4995 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8:: Value>& info)
4952 { 4996 {
4953 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 4997 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4954 TestObjectV8Internal::voidMethodShortArgMethod(info); 4998 TestObjectV8Internal::voidMethodShortArgMethod(info);
4955 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 4999 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4956 } 5000 }
4957 5001
4958 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 5002 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
4959 { 5003 {
4960 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedLongArg", "TestObject", info.Holder(), info.GetIsolate()); 5004 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedLongArg", "TestObject", info.Holder(), info.GetIsolate());
4961 if (UNLIKELY(info.Length() < 1)) { 5005 if (UNLIKELY(info.Length() < 1)) {
4962 throwArityTypeError(exceptionState, 1, info.Length()); 5006 throwArityTypeError(exceptionState, 1, info.Length());
4963 return; 5007 return;
4964 } 5008 }
4965 TestObject* impl = V8TestObject::toNative(info.Holder()); 5009 TestObject* impl = V8TestObject::toNative(info.Holder());
4966 TONATIVE_VOID_EXCEPTIONSTATE(unsigned, unsignedLongArg, toUInt32(info[0], ex ceptionState), exceptionState); 5010 unsigned unsignedLongArg;
5011 {
5012 v8::TryCatch block;
5013 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedLongArg, toUInt32(info[0], exceptionState), exceptionState);
5014 }
4967 impl->voidMethodUnsignedLongArg(unsignedLongArg); 5015 impl->voidMethodUnsignedLongArg(unsignedLongArg);
4968 } 5016 }
4969 5017
4970 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 5018 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
4971 { 5019 {
4972 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5020 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4973 TestObjectV8Internal::voidMethodUnsignedLongArgMethod(info); 5021 TestObjectV8Internal::voidMethodUnsignedLongArgMethod(info);
4974 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5022 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4975 } 5023 }
4976 5024
4977 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v 8::Value>& info) 5025 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v 8::Value>& info)
4978 { 5026 {
4979 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedLongLongArg", "TestObject", info.Holder(), info.GetIsolate()); 5027 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedLongLongArg", "TestObject", info.Holder(), info.GetIsolate());
4980 if (UNLIKELY(info.Length() < 1)) { 5028 if (UNLIKELY(info.Length() < 1)) {
4981 throwArityTypeError(exceptionState, 1, info.Length()); 5029 throwArityTypeError(exceptionState, 1, info.Length());
4982 return; 5030 return;
4983 } 5031 }
4984 TestObject* impl = V8TestObject::toNative(info.Holder()); 5032 TestObject* impl = V8TestObject::toNative(info.Holder());
4985 TONATIVE_VOID_EXCEPTIONSTATE(unsigned long long, unsignedLongLongArg, toUInt 64(info[0], exceptionState), exceptionState); 5033 unsigned long long unsignedLongLongArg;
5034 {
5035 v8::TryCatch block;
5036 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedLongLongArg, toUInt64(info[ 0], exceptionState), exceptionState);
5037 }
4986 impl->voidMethodUnsignedLongLongArg(unsignedLongLongArg); 5038 impl->voidMethodUnsignedLongLongArg(unsignedLongLongArg);
4987 } 5039 }
4988 5040
4989 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba ckInfo<v8::Value>& info) 5041 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba ckInfo<v8::Value>& info)
4990 { 5042 {
4991 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5043 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4992 TestObjectV8Internal::voidMethodUnsignedLongLongArgMethod(info); 5044 TestObjectV8Internal::voidMethodUnsignedLongLongArgMethod(info);
4993 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5045 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4994 } 5046 }
4995 5047
4996 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info) 5048 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info)
4997 { 5049 {
4998 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedShortArg", "TestObject", info.Holder(), info.GetIsolate()); 5050 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU nsignedShortArg", "TestObject", info.Holder(), info.GetIsolate());
4999 if (UNLIKELY(info.Length() < 1)) { 5051 if (UNLIKELY(info.Length() < 1)) {
5000 throwArityTypeError(exceptionState, 1, info.Length()); 5052 throwArityTypeError(exceptionState, 1, info.Length());
5001 return; 5053 return;
5002 } 5054 }
5003 TestObject* impl = V8TestObject::toNative(info.Holder()); 5055 TestObject* impl = V8TestObject::toNative(info.Holder());
5004 TONATIVE_VOID_EXCEPTIONSTATE(unsigned, unsignedShortArg, toUInt16(info[0], e xceptionState), exceptionState); 5056 unsigned unsignedShortArg;
5057 {
5058 v8::TryCatch block;
5059 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(unsignedShortArg, toUInt16(info[0], exceptionState), exceptionState);
5060 }
5005 impl->voidMethodUnsignedShortArg(unsignedShortArg); 5061 impl->voidMethodUnsignedShortArg(unsignedShortArg);
5006 } 5062 }
5007 5063
5008 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info) 5064 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info)
5009 { 5065 {
5010 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5066 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5011 TestObjectV8Internal::voidMethodUnsignedShortArgMethod(info); 5067 TestObjectV8Internal::voidMethodUnsignedShortArgMethod(info);
5012 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5068 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5013 } 5069 }
5014 5070
(...skipping 10 matching lines...) Expand all
5025 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5081 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5026 } 5082 }
5027 5083
5028 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info) 5084 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info)
5029 { 5085 {
5030 if (UNLIKELY(info.Length() < 1)) { 5086 if (UNLIKELY(info.Length() < 1)) {
5031 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyArg", "TestObj ect", 1, info.Length(), info.GetIsolate()); 5087 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyArg", "TestObj ect", 1, info.Length(), info.GetIsolate());
5032 return; 5088 return;
5033 } 5089 }
5034 TestObject* impl = V8TestObject::toNative(info.Holder()); 5090 TestObject* impl = V8TestObject::toNative(info.Holder());
5035 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 5091 TestInterfaceEmpty* testInterfaceEmptyArg;
5092 {
5093 v8::TryCatch block;
5094 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
5095 }
5036 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); 5096 impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
5037 } 5097 }
5038 5098
5039 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info) 5099 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info)
5040 { 5100 {
5041 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5101 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5042 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); 5102 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info);
5043 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5103 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5044 } 5104 }
5045 5105
5046 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb ackInfo<v8::Value>& info) 5106 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb ackInfo<v8::Value>& info)
5047 { 5107 {
5048 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); 5108 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate());
5049 if (UNLIKELY(info.Length() < 2)) { 5109 if (UNLIKELY(info.Length() < 2)) {
5050 throwArityTypeError(exceptionState, 2, info.Length()); 5110 throwArityTypeError(exceptionState, 2, info.Length());
5051 return; 5111 return;
5052 } 5112 }
5053 TestObject* impl = V8TestObject::toNative(info.Holder()); 5113 TestObject* impl = V8TestObject::toNative(info.Holder());
5054 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 5114 int longArg;
5055 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[1])); 5115 TestInterfaceEmpty* testInterfaceEmptyArg;
5116 {
5117 v8::TryCatch block;
5118 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
5119 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[1]));
5120 }
5056 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg) ; 5121 impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg) ;
5057 } 5122 }
5058 5123
5059 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct ionCallbackInfo<v8::Value>& info) 5124 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct ionCallbackInfo<v8::Value>& info)
5060 { 5125 {
5061 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5126 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5062 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info); 5127 TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info);
5063 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5128 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5064 } 5129 }
5065 5130
(...skipping 23 matching lines...) Expand all
5089 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5154 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5090 } 5155 }
5091 5156
5092 static void voidMethodVoidCallbackFunctionArgMethod(const v8::FunctionCallbackIn fo<v8::Value>& info) 5157 static void voidMethodVoidCallbackFunctionArgMethod(const v8::FunctionCallbackIn fo<v8::Value>& info)
5093 { 5158 {
5094 if (UNLIKELY(info.Length() < 1)) { 5159 if (UNLIKELY(info.Length() < 1)) {
5095 throwArityTypeErrorForMethod("voidMethodVoidCallbackFunctionArg", "TestO bject", 1, info.Length(), info.GetIsolate()); 5160 throwArityTypeErrorForMethod("voidMethodVoidCallbackFunctionArg", "TestO bject", 1, info.Length(), info.GetIsolate());
5096 return; 5161 return;
5097 } 5162 }
5098 TestObject* impl = V8TestObject::toNative(info.Holder()); 5163 TestObject* impl = V8TestObject::toNative(info.Holder());
5099 TONATIVE_VOID(ScriptValue, voidCallbackFunctionArg, ScriptValue(ScriptState: :current(info.GetIsolate()), info[0])); 5164 ScriptValue voidCallbackFunctionArg;
5165 {
5166 v8::TryCatch block;
5167 TONATIVE_VOID_NO_DECL(voidCallbackFunctionArg, ScriptValue(ScriptState:: current(info.GetIsolate()), info[0]));
5168 }
5100 impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg); 5169 impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg);
5101 } 5170 }
5102 5171
5103 static void voidMethodVoidCallbackFunctionArgMethodCallback(const v8::FunctionCa llbackInfo<v8::Value>& info) 5172 static void voidMethodVoidCallbackFunctionArgMethodCallback(const v8::FunctionCa llbackInfo<v8::Value>& info)
5104 { 5173 {
5105 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5174 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5106 TestObjectV8Internal::voidMethodVoidCallbackFunctionArgMethod(info); 5175 TestObjectV8Internal::voidMethodVoidCallbackFunctionArgMethod(info);
5107 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5176 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5108 } 5177 }
5109 5178
5110 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::Function CallbackInfo<v8::Value>& info) 5179 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::Function CallbackInfo<v8::Value>& info)
5111 { 5180 {
5112 if (UNLIKELY(info.Length() < 1)) { 5181 if (UNLIKELY(info.Length() < 1)) {
5113 throwArityTypeErrorForMethod("voidMethodAnyCallbackFunctionOptionalAnyAr g", "TestObject", 1, info.Length(), info.GetIsolate()); 5182 throwArityTypeErrorForMethod("voidMethodAnyCallbackFunctionOptionalAnyAr g", "TestObject", 1, info.Length(), info.GetIsolate());
5114 return; 5183 return;
5115 } 5184 }
5116 TestObject* impl = V8TestObject::toNative(info.Holder()); 5185 TestObject* impl = V8TestObject::toNative(info.Holder());
5117 TONATIVE_VOID(ScriptValue, anyCallbackFunctionOptionalAnyArgArg, ScriptValue (ScriptState::current(info.GetIsolate()), info[0])); 5186 ScriptValue anyCallbackFunctionOptionalAnyArgArg;
5187 {
5188 v8::TryCatch block;
5189 TONATIVE_VOID_NO_DECL(anyCallbackFunctionOptionalAnyArgArg, ScriptValue( ScriptState::current(info.GetIsolate()), info[0]));
5190 }
5118 impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptiona lAnyArgArg); 5191 impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptiona lAnyArgArg);
5119 } 5192 }
5120 5193
5121 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback(const v8:: FunctionCallbackInfo<v8::Value>& info) 5194 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback(const v8:: FunctionCallbackInfo<v8::Value>& info)
5122 { 5195 {
5123 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5196 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5124 TestObjectV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethod(info ); 5197 TestObjectV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethod(info );
5125 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5198 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5126 } 5199 }
5127 5200
(...skipping 23 matching lines...) Expand all
5151 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5224 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5152 } 5225 }
5153 5226
5154 static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info) 5227 static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info)
5155 { 5228 {
5156 if (UNLIKELY(info.Length() < 1)) { 5229 if (UNLIKELY(info.Length() < 1)) {
5157 throwArityTypeErrorForMethod("voidMethodCompareHowArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5230 throwArityTypeErrorForMethod("voidMethodCompareHowArg", "TestObject", 1, info.Length(), info.GetIsolate());
5158 return; 5231 return;
5159 } 5232 }
5160 TestObject* impl = V8TestObject::toNative(info.Holder()); 5233 TestObject* impl = V8TestObject::toNative(info.Holder());
5161 TONATIVE_VOID(Range::CompareHow, compareHowArg, static_cast<Range::CompareHo w>(info[0]->Int32Value())); 5234 Range::CompareHow compareHowArg;
5235 {
5236 v8::TryCatch block;
5237 TONATIVE_VOID_NO_DECL(compareHowArg, static_cast<Range::CompareHow>(info [0]->Int32Value()));
5238 }
5162 impl->voidMethodCompareHowArg(compareHowArg); 5239 impl->voidMethodCompareHowArg(compareHowArg);
5163 } 5240 }
5164 5241
5165 static void voidMethodCompareHowArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info) 5242 static void voidMethodCompareHowArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info)
5166 { 5243 {
5167 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5244 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5168 TestObjectV8Internal::voidMethodCompareHowArgMethod(info); 5245 TestObjectV8Internal::voidMethodCompareHowArgMethod(info);
5169 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5246 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5170 } 5247 }
5171 5248
5172 static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info) 5249 static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info)
5173 { 5250 {
5174 if (UNLIKELY(info.Length() < 1)) { 5251 if (UNLIKELY(info.Length() < 1)) {
5175 throwArityTypeErrorForMethod("voidMethodEventTargetArg", "TestObject", 1 , info.Length(), info.GetIsolate()); 5252 throwArityTypeErrorForMethod("voidMethodEventTargetArg", "TestObject", 1 , info.Length(), info.GetIsolate());
5176 return; 5253 return;
5177 } 5254 }
5178 TestObject* impl = V8TestObject::toNative(info.Holder()); 5255 TestObject* impl = V8TestObject::toNative(info.Holder());
5179 TONATIVE_VOID(EventTarget*, eventTargetArg, V8DOMWrapper::isDOMWrapper(info[ 0]) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8 ::Handle<v8::Object>::Cast(info[0])) : 0); 5256 EventTarget* eventTargetArg;
5257 {
5258 v8::TryCatch block;
5259 TONATIVE_VOID_NO_DECL(eventTargetArg, V8DOMWrapper::isDOMWrapper(info[0] ) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8:: Handle<v8::Object>::Cast(info[0])) : 0);
5260 }
5180 impl->voidMethodEventTargetArg(eventTargetArg); 5261 impl->voidMethodEventTargetArg(eventTargetArg);
5181 } 5262 }
5182 5263
5183 static void voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info) 5264 static void voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info)
5184 { 5265 {
5185 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5266 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5186 TestObjectV8Internal::voidMethodEventTargetArgMethod(info); 5267 TestObjectV8Internal::voidMethodEventTargetArgMethod(info);
5187 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5268 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5188 } 5269 }
5189 5270
5190 static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallback Info<v8::Value>& info) 5271 static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallback Info<v8::Value>& info)
5191 { 5272 {
5192 if (UNLIKELY(info.Length() < 1)) { 5273 if (UNLIKELY(info.Length() < 1)) {
5193 throwArityTypeErrorForMethod("voidMethodMediaQueryListListenerArg", "Tes tObject", 1, info.Length(), info.GetIsolate()); 5274 throwArityTypeErrorForMethod("voidMethodMediaQueryListListenerArg", "Tes tObject", 1, info.Length(), info.GetIsolate());
5194 return; 5275 return;
5195 } 5276 }
5196 TestObject* impl = V8TestObject::toNative(info.Holder()); 5277 TestObject* impl = V8TestObject::toNative(info.Holder());
5197 TONATIVE_VOID(RefPtrWillBeRawPtr<MediaQueryListListener>, mediaQueryListList enerArg, MediaQueryListListener::create(ScriptValue(ScriptState::current(info.Ge tIsolate()), info[0]))); 5278 RefPtrWillBeRawPtr<MediaQueryListListener> mediaQueryListListenerArg;
5279 {
5280 v8::TryCatch block;
5281 TONATIVE_VOID_NO_DECL(mediaQueryListListenerArg, MediaQueryListListener: :create(ScriptValue(ScriptState::current(info.GetIsolate()), info[0])));
5282 }
5198 impl->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg); 5283 impl->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg);
5199 } 5284 }
5200 5285
5201 static void voidMethodMediaQueryListListenerArgMethodCallback(const v8::Function CallbackInfo<v8::Value>& info) 5286 static void voidMethodMediaQueryListListenerArgMethodCallback(const v8::Function CallbackInfo<v8::Value>& info)
5202 { 5287 {
5203 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5288 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5204 TestObjectV8Internal::voidMethodMediaQueryListListenerArgMethod(info); 5289 TestObjectV8Internal::voidMethodMediaQueryListListenerArgMethod(info);
5205 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5290 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5206 } 5291 }
5207 5292
5208 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in fo) 5293 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in fo)
5209 { 5294 {
5210 if (UNLIKELY(info.Length() < 1)) { 5295 if (UNLIKELY(info.Length() < 1)) {
5211 throwArityTypeErrorForMethod("voidMethodAnyArg", "TestObject", 1, info.L ength(), info.GetIsolate()); 5296 throwArityTypeErrorForMethod("voidMethodAnyArg", "TestObject", 1, info.L ength(), info.GetIsolate());
5212 return; 5297 return;
5213 } 5298 }
5214 TestObject* impl = V8TestObject::toNative(info.Holder()); 5299 TestObject* impl = V8TestObject::toNative(info.Holder());
5215 TONATIVE_VOID(ScriptValue, anyArg, ScriptValue(ScriptState::current(info.Get Isolate()), info[0])); 5300 ScriptValue anyArg;
5301 {
5302 v8::TryCatch block;
5303 TONATIVE_VOID_NO_DECL(anyArg, ScriptValue(ScriptState::current(info.GetI solate()), info[0]));
5304 }
5216 impl->voidMethodAnyArg(anyArg); 5305 impl->voidMethodAnyArg(anyArg);
5217 } 5306 }
5218 5307
5219 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va lue>& info) 5308 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va lue>& info)
5220 { 5309 {
5221 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5310 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5222 TestObjectV8Internal::voidMethodAnyArgMethod(info); 5311 TestObjectV8Internal::voidMethodAnyArgMethod(info);
5223 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5312 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5224 } 5313 }
5225 5314
5226 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 5315 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
5227 { 5316 {
5228 if (UNLIKELY(info.Length() < 1)) { 5317 if (UNLIKELY(info.Length() < 1)) {
5229 throwArityTypeErrorForMethod("voidMethodAttrArg", "TestObject", 1, info. Length(), info.GetIsolate()); 5318 throwArityTypeErrorForMethod("voidMethodAttrArg", "TestObject", 1, info. Length(), info.GetIsolate());
5230 return; 5319 return;
5231 } 5320 }
5232 TestObject* impl = V8TestObject::toNative(info.Holder()); 5321 TestObject* impl = V8TestObject::toNative(info.Holder());
5233 TONATIVE_VOID(Attr*, attrArg, V8Attr::toNativeWithTypeCheck(info.GetIsolate( ), info[0])); 5322 Attr* attrArg;
5323 {
5324 v8::TryCatch block;
5325 TONATIVE_VOID_NO_DECL(attrArg, V8Attr::toNativeWithTypeCheck(info.GetIso late(), info[0]));
5326 }
5234 impl->voidMethodAttrArg(attrArg); 5327 impl->voidMethodAttrArg(attrArg);
5235 } 5328 }
5236 5329
5237 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info) 5330 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info)
5238 { 5331 {
5239 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5332 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5240 TestObjectV8Internal::voidMethodAttrArgMethod(info); 5333 TestObjectV8Internal::voidMethodAttrArgMethod(info);
5241 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5334 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5242 } 5335 }
5243 5336
5244 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info) 5337 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info)
5245 { 5338 {
5246 if (UNLIKELY(info.Length() < 1)) { 5339 if (UNLIKELY(info.Length() < 1)) {
5247 throwArityTypeErrorForMethod("voidMethodDocumentArg", "TestObject", 1, i nfo.Length(), info.GetIsolate()); 5340 throwArityTypeErrorForMethod("voidMethodDocumentArg", "TestObject", 1, i nfo.Length(), info.GetIsolate());
5248 return; 5341 return;
5249 } 5342 }
5250 TestObject* impl = V8TestObject::toNative(info.Holder()); 5343 TestObject* impl = V8TestObject::toNative(info.Holder());
5251 TONATIVE_VOID(Document*, documentArg, V8Document::toNativeWithTypeCheck(info .GetIsolate(), info[0])); 5344 Document* documentArg;
5345 {
5346 v8::TryCatch block;
5347 TONATIVE_VOID_NO_DECL(documentArg, V8Document::toNativeWithTypeCheck(inf o.GetIsolate(), info[0]));
5348 }
5252 impl->voidMethodDocumentArg(documentArg); 5349 impl->voidMethodDocumentArg(documentArg);
5253 } 5350 }
5254 5351
5255 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info) 5352 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info)
5256 { 5353 {
5257 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5354 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5258 TestObjectV8Internal::voidMethodDocumentArgMethod(info); 5355 TestObjectV8Internal::voidMethodDocumentArgMethod(info);
5259 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5356 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5260 } 5357 }
5261 5358
5262 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 5359 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
5263 { 5360 {
5264 if (UNLIKELY(info.Length() < 1)) { 5361 if (UNLIKELY(info.Length() < 1)) {
5265 throwArityTypeErrorForMethod("voidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5362 throwArityTypeErrorForMethod("voidMethodDocumentTypeArg", "TestObject", 1, info.Length(), info.GetIsolate());
5266 return; 5363 return;
5267 } 5364 }
5268 TestObject* impl = V8TestObject::toNative(info.Holder()); 5365 TestObject* impl = V8TestObject::toNative(info.Holder());
5269 TONATIVE_VOID(DocumentType*, documentTypeArg, V8DocumentType::toNativeWithTy peCheck(info.GetIsolate(), info[0])); 5366 DocumentType* documentTypeArg;
5367 {
5368 v8::TryCatch block;
5369 TONATIVE_VOID_NO_DECL(documentTypeArg, V8DocumentType::toNativeWithTypeC heck(info.GetIsolate(), info[0]));
5370 }
5270 impl->voidMethodDocumentTypeArg(documentTypeArg); 5371 impl->voidMethodDocumentTypeArg(documentTypeArg);
5271 } 5372 }
5272 5373
5273 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 5374 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
5274 { 5375 {
5275 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5376 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5276 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info); 5377 TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info);
5277 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5378 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5278 } 5379 }
5279 5380
5280 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info) 5381 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info)
5281 { 5382 {
5282 if (UNLIKELY(info.Length() < 1)) { 5383 if (UNLIKELY(info.Length() < 1)) {
5283 throwArityTypeErrorForMethod("voidMethodElementArg", "TestObject", 1, in fo.Length(), info.GetIsolate()); 5384 throwArityTypeErrorForMethod("voidMethodElementArg", "TestObject", 1, in fo.Length(), info.GetIsolate());
5284 return; 5385 return;
5285 } 5386 }
5286 TestObject* impl = V8TestObject::toNative(info.Holder()); 5387 TestObject* impl = V8TestObject::toNative(info.Holder());
5287 TONATIVE_VOID(Element*, elementArg, V8Element::toNativeWithTypeCheck(info.Ge tIsolate(), info[0])); 5388 Element* elementArg;
5389 {
5390 v8::TryCatch block;
5391 TONATIVE_VOID_NO_DECL(elementArg, V8Element::toNativeWithTypeCheck(info. GetIsolate(), info[0]));
5392 }
5288 impl->voidMethodElementArg(elementArg); 5393 impl->voidMethodElementArg(elementArg);
5289 } 5394 }
5290 5395
5291 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info) 5396 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info)
5292 { 5397 {
5293 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5398 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5294 TestObjectV8Internal::voidMethodElementArgMethod(info); 5399 TestObjectV8Internal::voidMethodElementArgMethod(info);
5295 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5400 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5296 } 5401 }
5297 5402
5298 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 5403 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
5299 { 5404 {
5300 if (UNLIKELY(info.Length() < 1)) { 5405 if (UNLIKELY(info.Length() < 1)) {
5301 throwArityTypeErrorForMethod("voidMethodNodeArg", "TestObject", 1, info. Length(), info.GetIsolate()); 5406 throwArityTypeErrorForMethod("voidMethodNodeArg", "TestObject", 1, info. Length(), info.GetIsolate());
5302 return; 5407 return;
5303 } 5408 }
5304 TestObject* impl = V8TestObject::toNative(info.Holder()); 5409 TestObject* impl = V8TestObject::toNative(info.Holder());
5305 TONATIVE_VOID(Node*, nodeArg, V8Node::toNativeWithTypeCheck(info.GetIsolate( ), info[0])); 5410 Node* nodeArg;
5411 {
5412 v8::TryCatch block;
5413 TONATIVE_VOID_NO_DECL(nodeArg, V8Node::toNativeWithTypeCheck(info.GetIso late(), info[0]));
5414 }
5306 impl->voidMethodNodeArg(nodeArg); 5415 impl->voidMethodNodeArg(nodeArg);
5307 } 5416 }
5308 5417
5309 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info) 5418 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V alue>& info)
5310 { 5419 {
5311 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5420 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5312 TestObjectV8Internal::voidMethodNodeArgMethod(info); 5421 TestObjectV8Internal::voidMethodNodeArgMethod(info);
5313 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5422 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5314 } 5423 }
5315 5424
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after
5378 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5487 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5379 } 5488 }
5380 5489
5381 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info) 5490 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info)
5382 { 5491 {
5383 if (UNLIKELY(info.Length() < 1)) { 5492 if (UNLIKELY(info.Length() < 1)) {
5384 throwArityTypeErrorForMethod("voidMethodArrayBufferArg", "TestObject", 1 , info.Length(), info.GetIsolate()); 5493 throwArityTypeErrorForMethod("voidMethodArrayBufferArg", "TestObject", 1 , info.Length(), info.GetIsolate());
5385 return; 5494 return;
5386 } 5495 }
5387 TestObject* impl = V8TestObject::toNative(info.Holder()); 5496 TestObject* impl = V8TestObject::toNative(info.Holder());
5388 TONATIVE_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8Arr ayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); 5497 ArrayBuffer* arrayBufferArg;
5498 {
5499 v8::TryCatch block;
5500 TONATIVE_VOID_NO_DECL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8Array Buffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
5501 }
5389 impl->voidMethodArrayBufferArg(arrayBufferArg); 5502 impl->voidMethodArrayBufferArg(arrayBufferArg);
5390 } 5503 }
5391 5504
5392 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info) 5505 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info)
5393 { 5506 {
5394 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5507 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5395 TestObjectV8Internal::voidMethodArrayBufferArgMethod(info); 5508 TestObjectV8Internal::voidMethodArrayBufferArgMethod(info);
5396 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5509 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5397 } 5510 }
5398 5511
5399 static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo< v8::Value>& info) 5512 static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo< v8::Value>& info)
5400 { 5513 {
5401 if (UNLIKELY(info.Length() < 1)) { 5514 if (UNLIKELY(info.Length() < 1)) {
5402 throwArityTypeErrorForMethod("voidMethodArrayBufferOrNullArg", "TestObje ct", 1, info.Length(), info.GetIsolate()); 5515 throwArityTypeErrorForMethod("voidMethodArrayBufferOrNullArg", "TestObje ct", 1, info.Length(), info.GetIsolate());
5403 return; 5516 return;
5404 } 5517 }
5405 TestObject* impl = V8TestObject::toNative(info.Holder()); 5518 TestObject* impl = V8TestObject::toNative(info.Holder());
5406 TONATIVE_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8Arr ayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); 5519 ArrayBuffer* arrayBufferArg;
5520 {
5521 v8::TryCatch block;
5522 TONATIVE_VOID_NO_DECL(arrayBufferArg, info[0]->IsArrayBuffer() ? V8Array Buffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
5523 }
5407 impl->voidMethodArrayBufferOrNullArg(arrayBufferArg); 5524 impl->voidMethodArrayBufferOrNullArg(arrayBufferArg);
5408 } 5525 }
5409 5526
5410 static void voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallb ackInfo<v8::Value>& info) 5527 static void voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallb ackInfo<v8::Value>& info)
5411 { 5528 {
5412 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5529 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5413 TestObjectV8Internal::voidMethodArrayBufferOrNullArgMethod(info); 5530 TestObjectV8Internal::voidMethodArrayBufferOrNullArgMethod(info);
5414 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5531 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5415 } 5532 }
5416 5533
5417 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8 ::Value>& info) 5534 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8 ::Value>& info)
5418 { 5535 {
5419 if (UNLIKELY(info.Length() < 1)) { 5536 if (UNLIKELY(info.Length() < 1)) {
5420 throwArityTypeErrorForMethod("voidMethodArrayBufferViewArg", "TestObject ", 1, info.Length(), info.GetIsolate()); 5537 throwArityTypeErrorForMethod("voidMethodArrayBufferViewArg", "TestObject ", 1, info.Length(), info.GetIsolate());
5421 return; 5538 return;
5422 } 5539 }
5423 TestObject* impl = V8TestObject::toNative(info.Holder()); 5540 TestObject* impl = V8TestObject::toNative(info.Holder());
5424 TONATIVE_VOID(ArrayBufferView*, arrayBufferViewArg, info[0]->IsArrayBufferVi ew() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[0] )) : 0); 5541 ArrayBufferView* arrayBufferViewArg;
5542 {
5543 v8::TryCatch block;
5544 TONATIVE_VOID_NO_DECL(arrayBufferViewArg, info[0]->IsArrayBufferView() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0 );
5545 }
5425 impl->voidMethodArrayBufferViewArg(arrayBufferViewArg); 5546 impl->voidMethodArrayBufferViewArg(arrayBufferViewArg);
5426 } 5547 }
5427 5548
5428 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac kInfo<v8::Value>& info) 5549 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac kInfo<v8::Value>& info)
5429 { 5550 {
5430 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5551 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5431 TestObjectV8Internal::voidMethodArrayBufferViewArgMethod(info); 5552 TestObjectV8Internal::voidMethodArrayBufferViewArgMethod(info);
5432 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5553 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5433 } 5554 }
5434 5555
5435 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 5556 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
5436 { 5557 {
5437 if (UNLIKELY(info.Length() < 1)) { 5558 if (UNLIKELY(info.Length() < 1)) {
5438 throwArityTypeErrorForMethod("voidMethodFloat32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5559 throwArityTypeErrorForMethod("voidMethodFloat32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate());
5439 return; 5560 return;
5440 } 5561 }
5441 TestObject* impl = V8TestObject::toNative(info.Holder()); 5562 TestObject* impl = V8TestObject::toNative(info.Holder());
5442 TONATIVE_VOID(Float32Array*, float32ArrayArg, info[0]->IsFloat32Array() ? V8 Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0); 5563 Float32Array* float32ArrayArg;
5564 {
5565 v8::TryCatch block;
5566 TONATIVE_VOID_NO_DECL(float32ArrayArg, info[0]->IsFloat32Array() ? V8Flo at32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0);
5567 }
5443 impl->voidMethodFloat32ArrayArg(float32ArrayArg); 5568 impl->voidMethodFloat32ArrayArg(float32ArrayArg);
5444 } 5569 }
5445 5570
5446 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 5571 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
5447 { 5572 {
5448 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5573 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5449 TestObjectV8Internal::voidMethodFloat32ArrayArgMethod(info); 5574 TestObjectV8Internal::voidMethodFloat32ArrayArgMethod(info);
5450 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5575 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5451 } 5576 }
5452 5577
5453 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info) 5578 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info)
5454 { 5579 {
5455 if (UNLIKELY(info.Length() < 1)) { 5580 if (UNLIKELY(info.Length() < 1)) {
5456 throwArityTypeErrorForMethod("voidMethodInt32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5581 throwArityTypeErrorForMethod("voidMethodInt32ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate());
5457 return; 5582 return;
5458 } 5583 }
5459 TestObject* impl = V8TestObject::toNative(info.Holder()); 5584 TestObject* impl = V8TestObject::toNative(info.Holder());
5460 TONATIVE_VOID(Int32Array*, int32ArrayArg, info[0]->IsInt32Array() ? V8Int32A rray::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0); 5585 Int32Array* int32ArrayArg;
5586 {
5587 v8::TryCatch block;
5588 TONATIVE_VOID_NO_DECL(int32ArrayArg, info[0]->IsInt32Array() ? V8Int32Ar ray::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0);
5589 }
5461 impl->voidMethodInt32ArrayArg(int32ArrayArg); 5590 impl->voidMethodInt32ArrayArg(int32ArrayArg);
5462 } 5591 }
5463 5592
5464 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info) 5593 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info)
5465 { 5594 {
5466 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5595 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5467 TestObjectV8Internal::voidMethodInt32ArrayArgMethod(info); 5596 TestObjectV8Internal::voidMethodInt32ArrayArgMethod(info);
5468 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5597 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5469 } 5598 }
5470 5599
5471 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info) 5600 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info)
5472 { 5601 {
5473 if (UNLIKELY(info.Length() < 1)) { 5602 if (UNLIKELY(info.Length() < 1)) {
5474 throwArityTypeErrorForMethod("voidMethodUint8ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5603 throwArityTypeErrorForMethod("voidMethodUint8ArrayArg", "TestObject", 1, info.Length(), info.GetIsolate());
5475 return; 5604 return;
5476 } 5605 }
5477 TestObject* impl = V8TestObject::toNative(info.Holder()); 5606 TestObject* impl = V8TestObject::toNative(info.Holder());
5478 TONATIVE_VOID(Uint8Array*, uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8A rray::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0); 5607 Uint8Array* uint8ArrayArg;
5608 {
5609 v8::TryCatch block;
5610 TONATIVE_VOID_NO_DECL(uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8Ar ray::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0);
5611 }
5479 impl->voidMethodUint8ArrayArg(uint8ArrayArg); 5612 impl->voidMethodUint8ArrayArg(uint8ArrayArg);
5480 } 5613 }
5481 5614
5482 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info) 5615 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info)
5483 { 5616 {
5484 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5617 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5485 TestObjectV8Internal::voidMethodUint8ArrayArgMethod(info); 5618 TestObjectV8Internal::voidMethodUint8ArrayArgMethod(info);
5486 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5619 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5487 } 5620 }
5488 5621
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
5525 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5658 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5526 } 5659 }
5527 5660
5528 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu e>& info) 5661 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu e>& info)
5529 { 5662 {
5530 if (UNLIKELY(info.Length() < 1)) { 5663 if (UNLIKELY(info.Length() < 1)) {
5531 throwArityTypeErrorForMethod("voidMethodArrayLongArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5664 throwArityTypeErrorForMethod("voidMethodArrayLongArg", "TestObject", 1, info.Length(), info.GetIsolate());
5532 return; 5665 return;
5533 } 5666 }
5534 TestObject* impl = V8TestObject::toNative(info.Holder()); 5667 TestObject* impl = V8TestObject::toNative(info.Holder());
5535 TONATIVE_VOID(Vector<int>, arrayLongArg, toNativeArray<int>(info[0], 1, info .GetIsolate())); 5668 Vector<int> arrayLongArg;
5669 {
5670 v8::TryCatch block;
5671 TONATIVE_VOID_NO_DECL(arrayLongArg, toNativeArray<int>(info[0], 1, info. GetIsolate()));
5672 }
5536 impl->voidMethodArrayLongArg(arrayLongArg); 5673 impl->voidMethodArrayLongArg(arrayLongArg);
5537 } 5674 }
5538 5675
5539 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo< v8::Value>& info) 5676 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo< v8::Value>& info)
5540 { 5677 {
5541 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5678 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5542 TestObjectV8Internal::voidMethodArrayLongArgMethod(info); 5679 TestObjectV8Internal::voidMethodArrayLongArgMethod(info);
5543 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5680 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5544 } 5681 }
5545 5682
5546 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info) 5683 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va lue>& info)
5547 { 5684 {
5548 if (UNLIKELY(info.Length() < 1)) { 5685 if (UNLIKELY(info.Length() < 1)) {
5549 throwArityTypeErrorForMethod("voidMethodArrayStringArg", "TestObject", 1 , info.Length(), info.GetIsolate()); 5686 throwArityTypeErrorForMethod("voidMethodArrayStringArg", "TestObject", 1 , info.Length(), info.GetIsolate());
5550 return; 5687 return;
5551 } 5688 }
5552 TestObject* impl = V8TestObject::toNative(info.Holder()); 5689 TestObject* impl = V8TestObject::toNative(info.Holder());
5553 TONATIVE_VOID(Vector<String>, arrayStringArg, toNativeArray<String>(info[0], 1, info.GetIsolate())); 5690 Vector<String> arrayStringArg;
5691 {
5692 v8::TryCatch block;
5693 TONATIVE_VOID_NO_DECL(arrayStringArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
5694 }
5554 impl->voidMethodArrayStringArg(arrayStringArg); 5695 impl->voidMethodArrayStringArg(arrayStringArg);
5555 } 5696 }
5556 5697
5557 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info) 5698 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf o<v8::Value>& info)
5558 { 5699 {
5559 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5700 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5560 TestObjectV8Internal::voidMethodArrayStringArgMethod(info); 5701 TestObjectV8Internal::voidMethodArrayStringArgMethod(info);
5561 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5702 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5562 } 5703 }
5563 5704
5564 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info) 5705 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info)
5565 { 5706 {
5566 if (UNLIKELY(info.Length() < 1)) { 5707 if (UNLIKELY(info.Length() < 1)) {
5567 throwArityTypeErrorForMethod("voidMethodArrayTestInterfaceEmptyArg", "Te stObject", 1, info.Length(), info.GetIsolate()); 5708 throwArityTypeErrorForMethod("voidMethodArrayTestInterfaceEmptyArg", "Te stObject", 1, info.Length(), info.GetIsolate());
5568 return; 5709 return;
5569 } 5710 }
5570 TestObject* impl = V8TestObject::toNative(info.Holder()); 5711 TestObject* impl = V8TestObject::toNative(info.Holder());
5571 TONATIVE_VOID(Vector<RefPtr<TestInterfaceEmpty> >, arrayTestInterfaceEmptyAr g, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, in fo.GetIsolate()))); 5712 Vector<RefPtr<TestInterfaceEmpty> > arrayTestInterfaceEmptyArg;
5713 {
5714 v8::TryCatch block;
5715 TONATIVE_VOID_NO_DECL(arrayTestInterfaceEmptyArg, (toRefPtrNativeArray<T estInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
5716 }
5572 impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg); 5717 impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg);
5573 } 5718 }
5574 5719
5575 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info) 5720 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info)
5576 { 5721 {
5577 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5722 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5578 TestObjectV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info); 5723 TestObjectV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info);
5579 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5724 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5580 } 5725 }
5581 5726
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
5618 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5763 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5619 } 5764 }
5620 5765
5621 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 5766 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
5622 { 5767 {
5623 if (UNLIKELY(info.Length() < 1)) { 5768 if (UNLIKELY(info.Length() < 1)) {
5624 throwArityTypeErrorForMethod("voidMethodSequenceLongArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5769 throwArityTypeErrorForMethod("voidMethodSequenceLongArg", "TestObject", 1, info.Length(), info.GetIsolate());
5625 return; 5770 return;
5626 } 5771 }
5627 TestObject* impl = V8TestObject::toNative(info.Holder()); 5772 TestObject* impl = V8TestObject::toNative(info.Holder());
5628 TONATIVE_VOID(Vector<int>, longSequenceArg, toNativeArray<int>(info[0], 1, i nfo.GetIsolate())); 5773 Vector<int> longSequenceArg;
5774 {
5775 v8::TryCatch block;
5776 TONATIVE_VOID_NO_DECL(longSequenceArg, toNativeArray<int>(info[0], 1, in fo.GetIsolate()));
5777 }
5629 impl->voidMethodSequenceLongArg(longSequenceArg); 5778 impl->voidMethodSequenceLongArg(longSequenceArg);
5630 } 5779 }
5631 5780
5632 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 5781 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
5633 { 5782 {
5634 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5783 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5635 TestObjectV8Internal::voidMethodSequenceLongArgMethod(info); 5784 TestObjectV8Internal::voidMethodSequenceLongArgMethod(info);
5636 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5785 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5637 } 5786 }
5638 5787
5639 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info) 5788 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info)
5640 { 5789 {
5641 if (UNLIKELY(info.Length() < 1)) { 5790 if (UNLIKELY(info.Length() < 1)) {
5642 throwArityTypeErrorForMethod("voidMethodSequenceStringArg", "TestObject" , 1, info.Length(), info.GetIsolate()); 5791 throwArityTypeErrorForMethod("voidMethodSequenceStringArg", "TestObject" , 1, info.Length(), info.GetIsolate());
5643 return; 5792 return;
5644 } 5793 }
5645 TestObject* impl = V8TestObject::toNative(info.Holder()); 5794 TestObject* impl = V8TestObject::toNative(info.Holder());
5646 TONATIVE_VOID(Vector<String>, stringSequenceArg, toNativeArray<String>(info[ 0], 1, info.GetIsolate())); 5795 Vector<String> stringSequenceArg;
5796 {
5797 v8::TryCatch block;
5798 TONATIVE_VOID_NO_DECL(stringSequenceArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
5799 }
5647 impl->voidMethodSequenceStringArg(stringSequenceArg); 5800 impl->voidMethodSequenceStringArg(stringSequenceArg);
5648 } 5801 }
5649 5802
5650 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info) 5803 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info)
5651 { 5804 {
5652 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5805 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5653 TestObjectV8Internal::voidMethodSequenceStringArgMethod(info); 5806 TestObjectV8Internal::voidMethodSequenceStringArgMethod(info);
5654 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5807 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5655 } 5808 }
5656 5809
5657 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info) 5810 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info)
5658 { 5811 {
5659 if (UNLIKELY(info.Length() < 1)) { 5812 if (UNLIKELY(info.Length() < 1)) {
5660 throwArityTypeErrorForMethod("voidMethodSequenceTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5813 throwArityTypeErrorForMethod("voidMethodSequenceTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate());
5661 return; 5814 return;
5662 } 5815 }
5663 TestObject* impl = V8TestObject::toNative(info.Holder()); 5816 TestObject* impl = V8TestObject::toNative(info.Holder());
5664 TONATIVE_VOID(Vector<RefPtr<TestInterfaceEmpty> >, testInterfaceEmptySequenc eArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate()))); 5817 Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptySequenceArg;
5818 {
5819 v8::TryCatch block;
5820 TONATIVE_VOID_NO_DECL(testInterfaceEmptySequenceArg, (toRefPtrNativeArra y<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
5821 }
5665 impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg) ; 5822 impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg) ;
5666 } 5823 }
5667 5824
5668 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info) 5825 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info)
5669 { 5826 {
5670 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5827 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5671 TestObjectV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info); 5828 TestObjectV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info);
5672 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5829 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5673 } 5830 }
5674 5831
5675 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba ckInfo<v8::Value>& info) 5832 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba ckInfo<v8::Value>& info)
5676 { 5833 {
5677 if (UNLIKELY(info.Length() < 1)) { 5834 if (UNLIKELY(info.Length() < 1)) {
5678 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyOrNullArg", "T estObject", 1, info.Length(), info.GetIsolate()); 5835 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyOrNullArg", "T estObject", 1, info.Length(), info.GetIsolate());
5679 return; 5836 return;
5680 } 5837 }
5681 TestObject* impl = V8TestObject::toNative(info.Holder()); 5838 TestObject* impl = V8TestObject::toNative(info.Holder());
5682 TONATIVE_VOID(TestInterfaceEmpty*, nullableTestInterfaceEmptyArg, V8TestInte rfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 5839 TestInterfaceEmpty* nullableTestInterfaceEmptyArg;
5840 {
5841 v8::TryCatch block;
5842 TONATIVE_VOID_NO_DECL(nullableTestInterfaceEmptyArg, V8TestInterfaceEmpt y::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
5843 }
5683 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg); 5844 impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg);
5684 } 5845 }
5685 5846
5686 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi onCallbackInfo<v8::Value>& info) 5847 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::Functi onCallbackInfo<v8::Value>& info)
5687 { 5848 {
5688 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5849 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5689 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info); 5850 TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info);
5690 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5851 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5691 } 5852 }
5692 5853
5693 static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackI nfo<v8::Value>& info) 5854 static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackI nfo<v8::Value>& info)
5694 { 5855 {
5695 if (UNLIKELY(info.Length() < 1)) { 5856 if (UNLIKELY(info.Length() < 1)) {
5696 throwArityTypeErrorForMethod("voidMethodTestCallbackInterfaceArg", "Test Object", 1, info.Length(), info.GetIsolate()); 5857 throwArityTypeErrorForMethod("voidMethodTestCallbackInterfaceArg", "Test Object", 1, info.Length(), info.GetIsolate());
5697 return; 5858 return;
5698 } 5859 }
5699 TestObject* impl = V8TestObject::toNative(info.Holder()); 5860 TestObject* impl = V8TestObject::toNative(info.Holder());
5700 if (info.Length() <= 0 || !info[0]->IsFunction()) { 5861 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
5701 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbac kInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a fun ction."), info.GetIsolate()); 5862 {
5702 return; 5863 if (info.Length() <= 0 || !info[0]->IsFunction()) {
5864 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCal lbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
5865 return;
5866 }
5867 testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8 ::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
5703 } 5868 }
5704 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInter face::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(in fo.GetIsolate()));
5705 impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release()) ; 5869 impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release()) ;
5706 } 5870 }
5707 5871
5708 static void voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionC allbackInfo<v8::Value>& info) 5872 static void voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionC allbackInfo<v8::Value>& info)
5709 { 5873 {
5710 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5874 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5711 TestObjectV8Internal::voidMethodTestCallbackInterfaceArgMethod(info); 5875 TestObjectV8Internal::voidMethodTestCallbackInterfaceArgMethod(info);
5712 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5876 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5713 } 5877 }
5714 5878
5715 static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionC allbackInfo<v8::Value>& info) 5879 static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionC allbackInfo<v8::Value>& info)
5716 { 5880 {
5717 TestObject* impl = V8TestObject::toNative(info.Holder()); 5881 TestObject* impl = V8TestObject::toNative(info.Holder());
5718 OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg; 5882 OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
5719 if (info.Length() > 0 && !isUndefinedOrNull(info[0])) { 5883 {
5720 if (!info[0]->IsFunction()) { 5884 if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
5721 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptiona lTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate()); 5885 if (!info[0]->IsFunction()) {
5722 return; 5886 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOpt ionalTestCallbackInterfaceArg", "TestObject", "The callback provided as paramete r 1 is not a function."), info.GetIsolate());
5887 return;
5888 }
5889 optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v 8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate( )));
5723 } 5890 }
5724 optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::H andle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
5725 } 5891 }
5726 impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfa ceArg.release()); 5892 impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfa ceArg.release());
5727 } 5893 }
5728 5894
5729 static void voidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::F unctionCallbackInfo<v8::Value>& info) 5895 static void voidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::F unctionCallbackInfo<v8::Value>& info)
5730 { 5896 {
5731 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5897 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5732 TestObjectV8Internal::voidMethodOptionalTestCallbackInterfaceArgMethod(info) ; 5898 TestObjectV8Internal::voidMethodOptionalTestCallbackInterfaceArgMethod(info) ;
5733 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5899 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5734 } 5900 }
5735 5901
5736 static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info) 5902 static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info)
5737 { 5903 {
5738 if (UNLIKELY(info.Length() < 1)) { 5904 if (UNLIKELY(info.Length() < 1)) {
5739 throwArityTypeErrorForMethod("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate()); 5905 throwArityTypeErrorForMethod("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate());
5740 return; 5906 return;
5741 } 5907 }
5742 TestObject* impl = V8TestObject::toNative(info.Holder()); 5908 TestObject* impl = V8TestObject::toNative(info.Holder());
5743 if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) { 5909 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
5744 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbac kInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate()); 5910 {
5745 return; 5911 if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
5912 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCal lbackInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
5913 return;
5914 }
5915 testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackI nterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContex t(info.GetIsolate()));
5746 } 5916 }
5747 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0 ]), currentExecutionContext(info.GetIsolate()));
5748 impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg.rele ase()); 5917 impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg.rele ase());
5749 } 5918 }
5750 5919
5751 static void voidMethodTestCallbackInterfaceOrNullArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info) 5920 static void voidMethodTestCallbackInterfaceOrNullArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info)
5752 { 5921 {
5753 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5922 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5754 TestObjectV8Internal::voidMethodTestCallbackInterfaceOrNullArgMethod(info); 5923 TestObjectV8Internal::voidMethodTestCallbackInterfaceOrNullArgMethod(info);
5755 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5924 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5756 } 5925 }
5757 5926
(...skipping 10 matching lines...) Expand all
5768 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5937 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5769 } 5938 }
5770 5939
5771 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info) 5940 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value >& info)
5772 { 5941 {
5773 if (UNLIKELY(info.Length() < 1)) { 5942 if (UNLIKELY(info.Length() < 1)) {
5774 throwArityTypeErrorForMethod("voidMethodTestEnumArg", "TestObject", 1, i nfo.Length(), info.GetIsolate()); 5943 throwArityTypeErrorForMethod("voidMethodTestEnumArg", "TestObject", 1, i nfo.Length(), info.GetIsolate());
5775 return; 5944 return;
5776 } 5945 }
5777 TestObject* impl = V8TestObject::toNative(info.Holder()); 5946 TestObject* impl = V8TestObject::toNative(info.Holder());
5778 TOSTRING_VOID(V8StringResource<>, testEnumTypeArg, info[0]); 5947 V8StringResource<> testEnumTypeArg;
5779 String string = testEnumTypeArg; 5948 {
5780 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || st ring == "EnumValue3")) { 5949 v8::TryCatch block;
5781 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg ", "TestObject", "parameter 1 ('" + string + "') is not a valid enum value."), i nfo.GetIsolate()); 5950 TOSTRING_VOID_NO_DECL(testEnumTypeArg, info[0]);
5782 return; 5951 String string = testEnumTypeArg;
5952 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" | | string == "EnumValue3")) {
5953 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnu mArg", "TestObject", "parameter 1 ('" + string + "') is not a valid enum value." ), info.GetIsolate());
5954 return;
5955 }
5783 } 5956 }
5784 impl->voidMethodTestEnumArg(testEnumTypeArg); 5957 impl->voidMethodTestEnumArg(testEnumTypeArg);
5785 } 5958 }
5786 5959
5787 static void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info) 5960 static void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v 8::Value>& info)
5788 { 5961 {
5789 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 5962 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5790 TestObjectV8Internal::voidMethodTestEnumArgMethod(info); 5963 TestObjectV8Internal::voidMethodTestEnumArgMethod(info);
5791 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 5964 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5792 } 5965 }
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
5856 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6029 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5857 } 6030 }
5858 6031
5859 static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info) 6032 static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info)
5860 { 6033 {
5861 if (UNLIKELY(info.Length() < 1)) { 6034 if (UNLIKELY(info.Length() < 1)) {
5862 throwArityTypeErrorForMethod("voidMethodDictionaryArg", "TestObject", 1, info.Length(), info.GetIsolate()); 6035 throwArityTypeErrorForMethod("voidMethodDictionaryArg", "TestObject", 1, info.Length(), info.GetIsolate());
5863 return; 6036 return;
5864 } 6037 }
5865 TestObject* impl = V8TestObject::toNative(info.Holder()); 6038 TestObject* impl = V8TestObject::toNative(info.Holder());
5866 TONATIVE_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsolate ())); 6039 Dictionary dictionaryArg;
5867 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) { 6040 {
5868 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryA rg", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetI solate()); 6041 v8::TryCatch block;
5869 return; 6042 TONATIVE_VOID_NO_DECL(dictionaryArg, Dictionary(info[0], info.GetIsolate ()));
6043 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
6044 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDiction aryArg", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info. GetIsolate());
6045 return;
6046 }
5870 } 6047 }
5871 impl->voidMethodDictionaryArg(dictionaryArg); 6048 impl->voidMethodDictionaryArg(dictionaryArg);
5872 } 6049 }
5873 6050
5874 static void voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info) 6051 static void voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info)
5875 { 6052 {
5876 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6053 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5877 TestObjectV8Internal::voidMethodDictionaryArgMethod(info); 6054 TestObjectV8Internal::voidMethodDictionaryArgMethod(info);
5878 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6055 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5879 } 6056 }
5880 6057
5881 static void voidMethodEventListenerArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info) 6058 static void voidMethodEventListenerArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info)
5882 { 6059 {
5883 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodE ventListenerArg", "TestObject", info.Holder(), info.GetIsolate()); 6060 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodE ventListenerArg", "TestObject", info.Holder(), info.GetIsolate());
5884 if (UNLIKELY(info.Length() < 1)) { 6061 if (UNLIKELY(info.Length() < 1)) {
5885 throwArityTypeError(exceptionState, 1, info.Length()); 6062 throwArityTypeError(exceptionState, 1, info.Length());
5886 return; 6063 return;
5887 } 6064 }
5888 TestObject* impl = V8TestObject::toNative(info.Holder()); 6065 TestObject* impl = V8TestObject::toNative(info.Holder());
5889 RefPtr<EventListener> eventListenerArg = V8EventListenerList::getEventListen er(info[1], false, ListenerFindOrCreate); 6066 RefPtr<EventListener> eventListenerArg;
6067 {
6068 eventListenerArg = V8EventListenerList::getEventListener(info[1], false, ListenerFindOrCreate);
6069 }
5890 impl->voidMethodEventListenerArg(eventListenerArg); 6070 impl->voidMethodEventListenerArg(eventListenerArg);
5891 if (listener && !impl->toNode()) 6071 if (listener && !impl->toNode())
5892 removeHiddenValueFromArray(info.Holder(), info[1], V8TestObject::eventLi stenerCacheIndex, info.GetIsolate()); 6072 removeHiddenValueFromArray(info.Holder(), info[1], V8TestObject::eventLi stenerCacheIndex, info.GetIsolate());
5893 } 6073 }
5894 6074
5895 static void voidMethodEventListenerArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info) 6075 static void voidMethodEventListenerArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info)
5896 { 6076 {
5897 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6077 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5898 TestObjectV8Internal::voidMethodEventListenerArgMethod(info); 6078 TestObjectV8Internal::voidMethodEventListenerArgMethod(info);
5899 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6079 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5900 } 6080 }
5901 6081
5902 static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info) 6082 static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Val ue>& info)
5903 { 6083 {
5904 if (UNLIKELY(info.Length() < 1)) { 6084 if (UNLIKELY(info.Length() < 1)) {
5905 throwArityTypeErrorForMethod("voidMethodNodeFilterArg", "TestObject", 1, info.Length(), info.GetIsolate()); 6085 throwArityTypeErrorForMethod("voidMethodNodeFilterArg", "TestObject", 1, info.Length(), info.GetIsolate());
5906 return; 6086 return;
5907 } 6087 }
5908 TestObject* impl = V8TestObject::toNative(info.Holder()); 6088 TestObject* impl = V8TestObject::toNative(info.Holder());
5909 TONATIVE_VOID(RefPtr<NodeFilter>, nodeFilterArg, toNodeFilter(info[0], info. GetIsolate())); 6089 RefPtr<NodeFilter> nodeFilterArg;
6090 {
6091 v8::TryCatch block;
6092 TONATIVE_VOID_NO_DECL(nodeFilterArg, toNodeFilter(info[0], info.GetIsola te()));
6093 }
5910 impl->voidMethodNodeFilterArg(nodeFilterArg.release()); 6094 impl->voidMethodNodeFilterArg(nodeFilterArg.release());
5911 } 6095 }
5912 6096
5913 static void voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info) 6097 static void voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo <v8::Value>& info)
5914 { 6098 {
5915 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6099 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5916 TestObjectV8Internal::voidMethodNodeFilterArgMethod(info); 6100 TestObjectV8Internal::voidMethodNodeFilterArgMethod(info);
5917 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6101 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5918 } 6102 }
5919 6103
5920 static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info) 6104 static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value> & info)
5921 { 6105 {
5922 if (UNLIKELY(info.Length() < 1)) { 6106 if (UNLIKELY(info.Length() < 1)) {
5923 throwArityTypeErrorForMethod("voidMethodPromiseArg", "TestObject", 1, in fo.Length(), info.GetIsolate()); 6107 throwArityTypeErrorForMethod("voidMethodPromiseArg", "TestObject", 1, in fo.Length(), info.GetIsolate());
5924 return; 6108 return;
5925 } 6109 }
5926 TestObject* impl = V8TestObject::toNative(info.Holder()); 6110 TestObject* impl = V8TestObject::toNative(info.Holder());
5927 TONATIVE_VOID(ScriptPromise, promiseArg, ScriptPromise(info[0], info.GetIsol ate())); 6111 ScriptPromise promiseArg;
5928 if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) { 6112 {
5929 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg" , "TestObject", "parameter 1 ('promiseArg') is not an object."), info.GetIsolate ()); 6113 v8::TryCatch block;
5930 return; 6114 TONATIVE_VOID_NO_DECL(promiseArg, ScriptPromise(info[0], info.GetIsolate ()));
6115 if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) {
6116 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromise Arg", "TestObject", "parameter 1 ('promiseArg') is not an object."), info.GetIso late());
6117 return;
6118 }
5931 } 6119 }
5932 impl->voidMethodPromiseArg(promiseArg); 6120 impl->voidMethodPromiseArg(promiseArg);
5933 } 6121 }
5934 6122
5935 static void voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info) 6123 static void voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8 ::Value>& info)
5936 { 6124 {
5937 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6125 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5938 TestObjectV8Internal::voidMethodPromiseArgMethod(info); 6126 TestObjectV8Internal::voidMethodPromiseArgMethod(info);
5939 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6127 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5940 } 6128 }
5941 6129
5942 static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackI nfo<v8::Value>& info) 6130 static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackI nfo<v8::Value>& info)
5943 { 6131 {
5944 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS erializedScriptValueArg", "TestObject", info.Holder(), info.GetIsolate()); 6132 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS erializedScriptValueArg", "TestObject", info.Holder(), info.GetIsolate());
5945 if (UNLIKELY(info.Length() < 1)) { 6133 if (UNLIKELY(info.Length() < 1)) {
5946 throwArityTypeError(exceptionState, 1, info.Length()); 6134 throwArityTypeError(exceptionState, 1, info.Length());
5947 return; 6135 return;
5948 } 6136 }
5949 TestObject* impl = V8TestObject::toNative(info.Holder()); 6137 TestObject* impl = V8TestObject::toNative(info.Holder());
5950 RefPtr<SerializedScriptValue> serializedScriptValueArg = SerializedScriptVal ue::create(info[0], 0, 0, exceptionState, info.GetIsolate()); 6138 RefPtr<SerializedScriptValue> serializedScriptValueArg;
5951 if (exceptionState.throwIfNeeded()) 6139 {
5952 return; 6140 serializedScriptValueArg = SerializedScriptValue::create(info[0], 0, 0, exceptionState, info.GetIsolate());
6141 if (exceptionState.throwIfNeeded())
6142 return;
6143 }
5953 impl->voidMethodSerializedScriptValueArg(serializedScriptValueArg); 6144 impl->voidMethodSerializedScriptValueArg(serializedScriptValueArg);
5954 } 6145 }
5955 6146
5956 static void voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionC allbackInfo<v8::Value>& info) 6147 static void voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionC allbackInfo<v8::Value>& info)
5957 { 6148 {
5958 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6149 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5959 TestObjectV8Internal::voidMethodSerializedScriptValueArgMethod(info); 6150 TestObjectV8Internal::voidMethodSerializedScriptValueArgMethod(info);
5960 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6151 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5961 } 6152 }
5962 6153
5963 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8 ::Value>& info) 6154 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8 ::Value>& info)
5964 { 6155 {
5965 if (UNLIKELY(info.Length() < 1)) { 6156 if (UNLIKELY(info.Length() < 1)) {
5966 throwArityTypeErrorForMethod("voidMethodXPathNSResolverArg", "TestObject ", 1, info.Length(), info.GetIsolate()); 6157 throwArityTypeErrorForMethod("voidMethodXPathNSResolverArg", "TestObject ", 1, info.Length(), info.GetIsolate());
5967 return; 6158 return;
5968 } 6159 }
5969 TestObject* impl = V8TestObject::toNative(info.Holder()); 6160 TestObject* impl = V8TestObject::toNative(info.Holder());
5970 TONATIVE_VOID(RefPtrWillBeRawPtr<XPathNSResolver>, xPathNSResolverArg, toXPa thNSResolver(info[0], info.GetIsolate())); 6161 RefPtrWillBeRawPtr<XPathNSResolver> xPathNSResolverArg;
6162 {
6163 v8::TryCatch block;
6164 TONATIVE_VOID_NO_DECL(xPathNSResolverArg, toXPathNSResolver(info[0], inf o.GetIsolate()));
6165 }
5971 impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release()); 6166 impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release());
5972 } 6167 }
5973 6168
5974 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac kInfo<v8::Value>& info) 6169 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac kInfo<v8::Value>& info)
5975 { 6170 {
5976 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6171 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5977 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info); 6172 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info);
5978 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6173 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5979 } 6174 }
5980 6175
5981 static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info) 6176 static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info)
5982 { 6177 {
5983 if (UNLIKELY(info.Length() < 1)) { 6178 if (UNLIKELY(info.Length() < 1)) {
5984 throwArityTypeErrorForMethod("voidMethodDictionarySequenceArg", "TestObj ect", 1, info.Length(), info.GetIsolate()); 6179 throwArityTypeErrorForMethod("voidMethodDictionarySequenceArg", "TestObj ect", 1, info.Length(), info.GetIsolate());
5985 return; 6180 return;
5986 } 6181 }
5987 TestObject* impl = V8TestObject::toNative(info.Holder()); 6182 TestObject* impl = V8TestObject::toNative(info.Holder());
5988 TONATIVE_VOID(Vector<Dictionary>, dictionarySequenceArg, toNativeArray<Dicti onary>(info[0], 1, info.GetIsolate())); 6183 Vector<Dictionary> dictionarySequenceArg;
6184 {
6185 v8::TryCatch block;
6186 TONATIVE_VOID_NO_DECL(dictionarySequenceArg, toNativeArray<Dictionary>(i nfo[0], 1, info.GetIsolate()));
6187 }
5989 impl->voidMethodDictionarySequenceArg(dictionarySequenceArg); 6188 impl->voidMethodDictionarySequenceArg(dictionarySequenceArg);
5990 } 6189 }
5991 6190
5992 static void voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info) 6191 static void voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info)
5993 { 6192 {
5994 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6193 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5995 TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info); 6194 TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info);
5996 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6195 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5997 } 6196 }
5998 6197
5999 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info) 6198 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8:: Value>& info)
6000 { 6199 {
6001 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS tringArgLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6200 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS tringArgLongArg", "TestObject", info.Holder(), info.GetIsolate());
6002 if (UNLIKELY(info.Length() < 2)) { 6201 if (UNLIKELY(info.Length() < 2)) {
6003 throwArityTypeError(exceptionState, 2, info.Length()); 6202 throwArityTypeError(exceptionState, 2, info.Length());
6004 return; 6203 return;
6005 } 6204 }
6006 TestObject* impl = V8TestObject::toNative(info.Holder()); 6205 TestObject* impl = V8TestObject::toNative(info.Holder());
6007 TOSTRING_VOID(V8StringResource<>, stringArg, info[0]); 6206 V8StringResource<> stringArg;
6008 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[1], exceptionState), exceptionState); 6207 int longArg;
6208 {
6209 v8::TryCatch block;
6210 TOSTRING_VOID_NO_DECL(stringArg, info[0]);
6211 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[1], exception State), exceptionState);
6212 }
6009 impl->voidMethodStringArgLongArg(stringArg, longArg); 6213 impl->voidMethodStringArgLongArg(stringArg, longArg);
6010 } 6214 }
6011 6215
6012 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info) 6216 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI nfo<v8::Value>& info)
6013 { 6217 {
6014 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6218 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6015 TestObjectV8Internal::voidMethodStringArgLongArgMethod(info); 6219 TestObjectV8Internal::voidMethodStringArgLongArgMethod(info);
6016 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6220 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6017 } 6221 }
6018 6222
6019 static void voidMethodOptionalStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info) 6223 static void voidMethodOptionalStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info)
6020 { 6224 {
6021 TestObject* impl = V8TestObject::toNative(info.Holder()); 6225 TestObject* impl = V8TestObject::toNative(info.Holder());
6022 if (UNLIKELY(info.Length() <= 0)) { 6226 V8StringResource<> optionalStringArg;
6023 impl->voidMethodOptionalStringArg(); 6227 {
6024 return; 6228 v8::TryCatch block;
6229 if (UNLIKELY(info.Length() <= 0)) {
6230 impl->voidMethodOptionalStringArg();
6231 return;
6232 }
6233 TOSTRING_VOID_NO_DECL(optionalStringArg, info[0]);
6025 } 6234 }
6026 TOSTRING_VOID(V8StringResource<>, optionalStringArg, info[0]);
6027 impl->voidMethodOptionalStringArg(optionalStringArg); 6235 impl->voidMethodOptionalStringArg(optionalStringArg);
6028 } 6236 }
6029 6237
6030 static void voidMethodOptionalStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info) 6238 static void voidMethodOptionalStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info)
6031 { 6239 {
6032 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6240 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6033 TestObjectV8Internal::voidMethodOptionalStringArgMethod(info); 6241 TestObjectV8Internal::voidMethodOptionalStringArgMethod(info);
6034 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6242 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6035 } 6243 }
6036 6244
6037 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info) 6245 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info)
6038 { 6246 {
6039 TestObject* impl = V8TestObject::toNative(info.Holder()); 6247 TestObject* impl = V8TestObject::toNative(info.Holder());
6040 if (UNLIKELY(info.Length() <= 0)) { 6248 TestInterfaceEmpty* optionalTestInterfaceEmptyArg;
6041 impl->voidMethodOptionalTestInterfaceEmptyArg(); 6249 {
6042 return; 6250 v8::TryCatch block;
6251 if (UNLIKELY(info.Length() <= 0)) {
6252 impl->voidMethodOptionalTestInterfaceEmptyArg();
6253 return;
6254 }
6255 TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmptyArg, V8TestInterfaceEmpt y::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6043 } 6256 }
6044 TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmptyArg, V8TestInte rfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6045 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg) ; 6257 impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg) ;
6046 } 6258 }
6047 6259
6048 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info) 6260 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info)
6049 { 6261 {
6050 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6262 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6051 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info); 6263 TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info);
6052 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6264 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6053 } 6265 }
6054 6266
6055 static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 6267 static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
6056 { 6268 {
6057 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO ptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6269 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO ptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
6058 TestObject* impl = V8TestObject::toNative(info.Holder()); 6270 TestObject* impl = V8TestObject::toNative(info.Holder());
6059 if (UNLIKELY(info.Length() <= 0)) { 6271 int optionalLongArg;
6060 impl->voidMethodOptionalLongArg(); 6272 {
6061 return; 6273 v8::TryCatch block;
6274 if (UNLIKELY(info.Length() <= 0)) {
6275 impl->voidMethodOptionalLongArg();
6276 return;
6277 }
6278 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], e xceptionState), exceptionState);
6062 } 6279 }
6063 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptio nState), exceptionState);
6064 impl->voidMethodOptionalLongArg(optionalLongArg); 6280 impl->voidMethodOptionalLongArg(optionalLongArg);
6065 } 6281 }
6066 6282
6067 static void voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 6283 static void voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
6068 { 6284 {
6069 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6285 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6070 TestObjectV8Internal::voidMethodOptionalLongArgMethod(info); 6286 TestObjectV8Internal::voidMethodOptionalLongArgMethod(info);
6071 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6287 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6072 } 6288 }
6073 6289
6074 static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info) 6290 static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info)
6075 { 6291 {
6076 ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringMetho dOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6292 ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringMetho dOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
6077 TestObject* impl = V8TestObject::toNative(info.Holder()); 6293 TestObject* impl = V8TestObject::toNative(info.Holder());
6078 if (UNLIKELY(info.Length() <= 0)) { 6294 int optionalLongArg;
6079 v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), info.G etIsolate()); 6295 {
6080 return; 6296 v8::TryCatch block;
6297 if (UNLIKELY(info.Length() <= 0)) {
6298 v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), in fo.GetIsolate());
6299 return;
6300 }
6301 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], e xceptionState), exceptionState);
6081 } 6302 }
6082 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptio nState), exceptionState);
6083 v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(optionalLongA rg), info.GetIsolate()); 6303 v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(optionalLongA rg), info.GetIsolate());
6084 } 6304 }
6085 6305
6086 static void stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info) 6306 static void stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info)
6087 { 6307 {
6088 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6308 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6089 TestObjectV8Internal::stringMethodOptionalLongArgMethod(info); 6309 TestObjectV8Internal::stringMethodOptionalLongArgMethod(info);
6090 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6310 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6091 } 6311 }
6092 6312
6093 static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCall backInfo<v8::Value>& info) 6313 static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCall backInfo<v8::Value>& info)
6094 { 6314 {
6095 ExceptionState exceptionState(ExceptionState::ExecutionContext, "testInterfa ceEmptyMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6315 ExceptionState exceptionState(ExceptionState::ExecutionContext, "testInterfa ceEmptyMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
6096 TestObject* impl = V8TestObject::toNative(info.Holder()); 6316 TestObject* impl = V8TestObject::toNative(info.Holder());
6097 if (UNLIKELY(info.Length() <= 0)) { 6317 int optionalLongArg;
6098 v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg()); 6318 {
6099 return; 6319 v8::TryCatch block;
6320 if (UNLIKELY(info.Length() <= 0)) {
6321 v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg ());
6322 return;
6323 }
6324 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], e xceptionState), exceptionState);
6100 } 6325 }
6101 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptio nState), exceptionState);
6102 v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg(optiona lLongArg)); 6326 v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg(optiona lLongArg));
6103 } 6327 }
6104 6328
6105 static void testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info) 6329 static void testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info)
6106 { 6330 {
6107 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6331 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6108 TestObjectV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(info); 6332 TestObjectV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(info);
6109 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6333 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6110 } 6334 }
6111 6335
6112 static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 6336 static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
6113 { 6337 {
6114 ExceptionState exceptionState(ExceptionState::ExecutionContext, "longMethodO ptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6338 ExceptionState exceptionState(ExceptionState::ExecutionContext, "longMethodO ptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
6115 TestObject* impl = V8TestObject::toNative(info.Holder()); 6339 TestObject* impl = V8TestObject::toNative(info.Holder());
6116 if (UNLIKELY(info.Length() <= 0)) { 6340 int optionalLongArg;
6117 v8SetReturnValueInt(info, impl->longMethodOptionalLongArg()); 6341 {
6118 return; 6342 v8::TryCatch block;
6343 if (UNLIKELY(info.Length() <= 0)) {
6344 v8SetReturnValueInt(info, impl->longMethodOptionalLongArg());
6345 return;
6346 }
6347 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], e xceptionState), exceptionState);
6119 } 6348 }
6120 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptio nState), exceptionState);
6121 v8SetReturnValueInt(info, impl->longMethodOptionalLongArg(optionalLongArg)); 6349 v8SetReturnValueInt(info, impl->longMethodOptionalLongArg(optionalLongArg));
6122 } 6350 }
6123 6351
6124 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info) 6352 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn fo<v8::Value>& info)
6125 { 6353 {
6126 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6354 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6127 TestObjectV8Internal::longMethodOptionalLongArgMethod(info); 6355 TestObjectV8Internal::longMethodOptionalLongArgMethod(info);
6128 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6356 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6129 } 6357 }
6130 6358
6131 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf o<v8::Value>& info) 6359 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf o<v8::Value>& info)
6132 { 6360 {
6133 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 6361 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
6134 if (UNLIKELY(info.Length() < 1)) { 6362 if (UNLIKELY(info.Length() < 1)) {
6135 throwArityTypeError(exceptionState, 1, info.Length()); 6363 throwArityTypeError(exceptionState, 1, info.Length());
6136 return; 6364 return;
6137 } 6365 }
6138 TestObject* impl = V8TestObject::toNative(info.Holder()); 6366 TestObject* impl = V8TestObject::toNative(info.Holder());
6139 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6367 int longArg;
6140 if (UNLIKELY(info.Length() <= 1)) { 6368 int optionalLongArg;
6141 impl->voidMethodLongArgOptionalLongArg(longArg); 6369 {
6142 return; 6370 v8::TryCatch block;
6371 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6372 if (UNLIKELY(info.Length() <= 1)) {
6373 impl->voidMethodLongArgOptionalLongArg(longArg);
6374 return;
6375 }
6376 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[1], e xceptionState), exceptionState);
6143 } 6377 }
6144 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[1], exceptio nState), exceptionState);
6145 impl->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg); 6378 impl->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg);
6146 } 6379 }
6147 6380
6148 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal lbackInfo<v8::Value>& info) 6381 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal lbackInfo<v8::Value>& info)
6149 { 6382 {
6150 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6383 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6151 TestObjectV8Internal::voidMethodLongArgOptionalLongArgMethod(info); 6384 TestObjectV8Internal::voidMethodLongArgOptionalLongArgMethod(info);
6152 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6385 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6153 } 6386 }
6154 6387
6155 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info) 6388 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info)
6156 { 6389 {
6157 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalLongArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsol ate()); 6390 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalLongArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsol ate());
6158 if (UNLIKELY(info.Length() < 1)) { 6391 if (UNLIKELY(info.Length() < 1)) {
6159 throwArityTypeError(exceptionState, 1, info.Length()); 6392 throwArityTypeError(exceptionState, 1, info.Length());
6160 return; 6393 return;
6161 } 6394 }
6162 TestObject* impl = V8TestObject::toNative(info.Holder()); 6395 TestObject* impl = V8TestObject::toNative(info.Holder());
6163 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6396 int longArg;
6164 if (UNLIKELY(info.Length() <= 1)) { 6397 int optionalLongArg1;
6165 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg); 6398 int optionalLongArg2;
6166 return; 6399 {
6400 v8::TryCatch block;
6401 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6402 if (UNLIKELY(info.Length() <= 1)) {
6403 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg);
6404 return;
6405 }
6406 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg1, toInt32(info[1], exceptionState), exceptionState);
6407 if (UNLIKELY(info.Length() <= 2)) {
6408 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optio nalLongArg1);
6409 return;
6410 }
6411 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg2, toInt32(info[2], exceptionState), exceptionState);
6167 } 6412 }
6168 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg1, toInt32(info[1], excepti onState), exceptionState);
6169 if (UNLIKELY(info.Length() <= 2)) {
6170 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalL ongArg1);
6171 return;
6172 }
6173 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg2, toInt32(info[2], excepti onState), exceptionState);
6174 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongA rg1, optionalLongArg2); 6413 impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongA rg1, optionalLongArg2);
6175 } 6414 }
6176 6415
6177 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 6416 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6178 { 6417 {
6179 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6418 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6180 TestObjectV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgMethod( info); 6419 TestObjectV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgMethod( info);
6181 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6420 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6182 } 6421 }
6183 6422
6184 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct ionCallbackInfo<v8::Value>& info) 6423 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct ionCallbackInfo<v8::Value>& info)
6185 { 6424 {
6186 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsola te()); 6425 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL ongArgOptionalTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsola te());
6187 if (UNLIKELY(info.Length() < 1)) { 6426 if (UNLIKELY(info.Length() < 1)) {
6188 throwArityTypeError(exceptionState, 1, info.Length()); 6427 throwArityTypeError(exceptionState, 1, info.Length());
6189 return; 6428 return;
6190 } 6429 }
6191 TestObject* impl = V8TestObject::toNative(info.Holder()); 6430 TestObject* impl = V8TestObject::toNative(info.Holder());
6192 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6431 int longArg;
6193 if (UNLIKELY(info.Length() <= 1)) { 6432 TestInterfaceEmpty* optionalTestInterfaceEmpty;
6194 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); 6433 {
6195 return; 6434 v8::TryCatch block;
6435 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6436 if (UNLIKELY(info.Length() <= 1)) {
6437 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);
6438 return;
6439 }
6440 TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty:: toNativeWithTypeCheck(info.GetIsolate(), info[1]));
6196 } 6441 }
6197 TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfa ceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
6198 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn terfaceEmpty); 6442 impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestIn terfaceEmpty);
6199 } 6443 }
6200 6444
6201 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v 8::FunctionCallbackInfo<v8::Value>& info) 6445 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v 8::FunctionCallbackInfo<v8::Value>& info)
6202 { 6446 {
6203 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6447 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6204 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i nfo); 6448 TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(i nfo);
6205 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6449 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6206 } 6450 }
6207 6451
6208 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct ionCallbackInfo<v8::Value>& info) 6452 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct ionCallbackInfo<v8::Value>& info)
6209 { 6453 {
6210 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola te()); 6454 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT estInterfaceEmptyArgOptionalLongArg", "TestObject", info.Holder(), info.GetIsola te());
6211 if (UNLIKELY(info.Length() < 1)) { 6455 if (UNLIKELY(info.Length() < 1)) {
6212 throwArityTypeError(exceptionState, 1, info.Length()); 6456 throwArityTypeError(exceptionState, 1, info.Length());
6213 return; 6457 return;
6214 } 6458 }
6215 TestObject* impl = V8TestObject::toNative(info.Holder()); 6459 TestObject* impl = V8TestObject::toNative(info.Holder());
6216 TONATIVE_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfa ceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 6460 TestInterfaceEmpty* optionalTestInterfaceEmpty;
6217 if (UNLIKELY(info.Length() <= 1)) { 6461 int longArg;
6218 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfa ceEmpty); 6462 {
6219 return; 6463 v8::TryCatch block;
6464 TONATIVE_VOID_NO_DECL(optionalTestInterfaceEmpty, V8TestInterfaceEmpty:: toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6465 if (UNLIKELY(info.Length() <= 1)) {
6466 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInt erfaceEmpty);
6467 return;
6468 }
6469 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[1], exception State), exceptionState);
6220 } 6470 }
6221 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[1], exceptionState), exceptionState);
6222 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm pty, longArg); 6471 impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEm pty, longArg);
6223 } 6472 }
6224 6473
6225 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v 8::FunctionCallbackInfo<v8::Value>& info) 6474 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v 8::FunctionCallbackInfo<v8::Value>& info)
6226 { 6475 {
6227 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6476 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6228 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(i nfo); 6477 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(i nfo);
6229 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6478 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6230 } 6479 }
6231 6480
6232 static void voidMethodOptionalDictionaryArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info) 6481 static void voidMethodOptionalDictionaryArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info)
6233 { 6482 {
6234 TestObject* impl = V8TestObject::toNative(info.Holder()); 6483 TestObject* impl = V8TestObject::toNative(info.Holder());
6235 TONATIVE_VOID(Dictionary, optionalDictionaryArg, Dictionary(info[0], info.Ge tIsolate())); 6484 Dictionary optionalDictionaryArg;
6236 if (!optionalDictionaryArg.isUndefinedOrNull() && !optionalDictionaryArg.isO bject()) { 6485 {
6237 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalDic tionaryArg", "TestObject", "parameter 1 ('optionalDictionaryArg') is not an obje ct."), info.GetIsolate()); 6486 v8::TryCatch block;
6238 return; 6487 TONATIVE_VOID_NO_DECL(optionalDictionaryArg, Dictionary(info[0], info.Ge tIsolate()));
6488 if (!optionalDictionaryArg.isUndefinedOrNull() && !optionalDictionaryArg .isObject()) {
6489 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptiona lDictionaryArg", "TestObject", "parameter 1 ('optionalDictionaryArg') is not an object."), info.GetIsolate());
6490 return;
6491 }
6239 } 6492 }
6240 impl->voidMethodOptionalDictionaryArg(optionalDictionaryArg); 6493 impl->voidMethodOptionalDictionaryArg(optionalDictionaryArg);
6241 } 6494 }
6242 6495
6243 static void voidMethodOptionalDictionaryArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info) 6496 static void voidMethodOptionalDictionaryArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info)
6244 { 6497 {
6245 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6498 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6246 TestObjectV8Internal::voidMethodOptionalDictionaryArgMethod(info); 6499 TestObjectV8Internal::voidMethodOptionalDictionaryArgMethod(info);
6247 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6500 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6248 } 6501 }
6249 6502
6250 static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info) 6503 static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8: :Value>& info)
6251 { 6504 {
6252 TestObject* impl = V8TestObject::toNative(info.Holder()); 6505 TestObject* impl = V8TestObject::toNative(info.Holder());
6253 TONATIVE_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>( info, 0)); 6506 Vector<String> variadicStringArgs;
6507 {
6508 v8::TryCatch block;
6509 TONATIVE_VOID_NO_DECL(variadicStringArgs, toNativeArguments<String>(info , 0));
6510 }
6254 impl->voidMethodVariadicStringArg(variadicStringArgs); 6511 impl->voidMethodVariadicStringArg(variadicStringArgs);
6255 } 6512 }
6256 6513
6257 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info) 6514 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback Info<v8::Value>& info)
6258 { 6515 {
6259 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6516 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6260 TestObjectV8Internal::voidMethodVariadicStringArgMethod(info); 6517 TestObjectV8Internal::voidMethodVariadicStringArgMethod(info);
6261 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6518 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6262 } 6519 }
6263 6520
6264 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info) 6521 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info)
6265 { 6522 {
6266 if (UNLIKELY(info.Length() < 1)) { 6523 if (UNLIKELY(info.Length() < 1)) {
6267 throwArityTypeErrorForMethod("voidMethodStringArgVariadicStringArg", "Te stObject", 1, info.Length(), info.GetIsolate()); 6524 throwArityTypeErrorForMethod("voidMethodStringArgVariadicStringArg", "Te stObject", 1, info.Length(), info.GetIsolate());
6268 return; 6525 return;
6269 } 6526 }
6270 TestObject* impl = V8TestObject::toNative(info.Holder()); 6527 TestObject* impl = V8TestObject::toNative(info.Holder());
6271 TOSTRING_VOID(V8StringResource<>, stringArg, info[0]); 6528 V8StringResource<> stringArg;
6272 TONATIVE_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>( info, 1)); 6529 Vector<String> variadicStringArgs;
6530 {
6531 v8::TryCatch block;
6532 TOSTRING_VOID_NO_DECL(stringArg, info[0]);
6533 TONATIVE_VOID_NO_DECL(variadicStringArgs, toNativeArguments<String>(info , 1));
6534 }
6273 impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs); 6535 impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs);
6274 } 6536 }
6275 6537
6276 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info) 6538 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info)
6277 { 6539 {
6278 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6540 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6279 TestObjectV8Internal::voidMethodStringArgVariadicStringArgMethod(info); 6541 TestObjectV8Internal::voidMethodStringArgVariadicStringArgMethod(info);
6280 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6542 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6281 } 6543 }
6282 6544
6283 static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info) 6545 static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCall backInfo<v8::Value>& info)
6284 { 6546 {
6285 TestObject* impl = V8TestObject::toNative(info.Holder()); 6547 TestObject* impl = V8TestObject::toNative(info.Holder());
6286 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; 6548 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
6287 for (int i = 0; i < info.Length(); ++i) { 6549 {
6288 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) { 6550 for (int i = 0; i < info.Length(); ++i) {
6289 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadi cTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfac eEmpty'."), info.GetIsolate()); 6551 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
6290 return; 6552 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVar iadicTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInte rfaceEmpty'."), info.GetIsolate());
6553 return;
6554 }
6555 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative (v8::Handle<v8::Object>::Cast(info[i])));
6291 } 6556 }
6292 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8: :Handle<v8::Object>::Cast(info[i])));
6293 } 6557 }
6294 impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs ); 6558 impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs );
6295 } 6559 }
6296 6560
6297 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info) 6561 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func tionCallbackInfo<v8::Value>& info)
6298 { 6562 {
6299 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6563 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6300 TestObjectV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info); 6564 TestObjectV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info);
6301 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6565 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6302 } 6566 }
6303 6567
6304 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c onst v8::FunctionCallbackInfo<v8::Value>& info) 6568 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c onst v8::FunctionCallbackInfo<v8::Value>& info)
6305 { 6569 {
6306 if (UNLIKELY(info.Length() < 1)) { 6570 if (UNLIKELY(info.Length() < 1)) {
6307 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyArgVariadicTes tInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate()); 6571 throwArityTypeErrorForMethod("voidMethodTestInterfaceEmptyArgVariadicTes tInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate());
6308 return; 6572 return;
6309 } 6573 }
6310 TestObject* impl = V8TestObject::toNative(info.Holder()); 6574 TestObject* impl = V8TestObject::toNative(info.Holder());
6311 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 6575 TestInterfaceEmpty* testInterfaceEmptyArg;
6312 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; 6576 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
6313 for (int i = 1; i < info.Length(); ++i) { 6577 {
6314 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) { 6578 v8::TryCatch block;
6315 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInt erfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); 6579 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
6316 return; 6580 for (int i = 1; i < info.Length(); ++i) {
6581 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
6582 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTes tInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
6583 return;
6584 }
6585 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative (v8::Handle<v8::Object>::Cast(info[i])));
6317 } 6586 }
6318 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8: :Handle<v8::Object>::Cast(info[i])));
6319 } 6587 }
6320 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter faceEmptyArg, variadicTestInterfaceEmptyArgs); 6588 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter faceEmptyArg, variadicTestInterfaceEmptyArgs);
6321 } 6589 }
6322 6590
6323 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa llback(const v8::FunctionCallbackInfo<v8::Value>& info) 6591 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa llback(const v8::FunctionCallbackInfo<v8::Value>& info)
6324 { 6592 {
6325 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6593 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6326 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEm ptyArgMethod(info); 6594 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEm ptyArgMethod(info);
6327 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6595 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6328 } 6596 }
6329 6597
6330 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::F unctionCallbackInfo<v8::Value>& info) 6598 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::F unctionCallbackInfo<v8::Value>& info)
6331 { 6599 {
6332 TestObject* impl = V8TestObject::toNative(info.Holder()); 6600 TestObject* impl = V8TestObject::toNative(info.Holder());
6333 HeapVector<Member<TestInterfaceGarbageCollected> > variadicTestInterfaceGarb ageCollectedArg; 6601 HeapVector<Member<TestInterfaceGarbageCollected> > variadicTestInterfaceGarb ageCollectedArg;
6334 for (int i = 0; i < info.Length(); ++i) { 6602 {
6335 if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetIsola te())) { 6603 for (int i = 0; i < info.Length(); ++i) {
6336 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadi cTestInterfaceGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'T estInterfaceGarbageCollected'."), info.GetIsolate()); 6604 if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetI solate())) {
6337 return; 6605 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVar iadicTestInterfaceGarbageCollectedArg", "TestObject", "parameter 1 is not of typ e 'TestInterfaceGarbageCollected'."), info.GetIsolate());
6606 return;
6607 }
6608 variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarba geCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6338 } 6609 }
6339 variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarbageCo llected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6340 } 6610 }
6341 impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfa ceGarbageCollectedArg); 6611 impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfa ceGarbageCollectedArg);
6342 } 6612 }
6343 6613
6344 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback(con st v8::FunctionCallbackInfo<v8::Value>& info) 6614 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback(con st v8::FunctionCallbackInfo<v8::Value>& info)
6345 { 6615 {
6346 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6616 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6347 TestObjectV8Internal::voidMethodVariadicTestInterfaceGarbageCollectedArgMeth od(info); 6617 TestObjectV8Internal::voidMethodVariadicTestInterfaceGarbageCollectedArgMeth od(info);
6348 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6618 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6349 } 6619 }
6350 6620
6351 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 6621 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6352 { 6622 {
6353 TestObject* impl = V8TestObject::toNative(info.Holder()); 6623 TestObject* impl = V8TestObject::toNative(info.Holder());
6354 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > v ariadicTestInterfaceWillBeGarbageCollectedArg; 6624 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > v ariadicTestInterfaceWillBeGarbageCollectedArg;
6355 for (int i = 0; i < info.Length(); ++i) { 6625 {
6356 if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], info.Ge tIsolate())) { 6626 for (int i = 0; i < info.Length(); ++i) {
6357 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadi cTestInterfaceWillBeGarbageCollectedArg", "TestObject", "parameter 1 is not of t ype 'TestInterfaceWillBeGarbageCollected'."), info.GetIsolate()); 6627 if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], inf o.GetIsolate())) {
6358 return; 6628 throwTypeError(ExceptionMessages::failedToExecute("voidMethodVar iadicTestInterfaceWillBeGarbageCollectedArg", "TestObject", "parameter 1 is not of type 'TestInterfaceWillBeGarbageCollected'."), info.GetIsolate());
6629 return;
6630 }
6631 variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfac eWillBeGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6359 } 6632 }
6360 variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfaceWil lBeGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6361 } 6633 }
6362 impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestI nterfaceWillBeGarbageCollectedArg); 6634 impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestI nterfaceWillBeGarbageCollectedArg);
6363 } 6635 }
6364 6636
6365 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info) 6637 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info)
6366 { 6638 {
6367 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 6639 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6368 TestObjectV8Internal::voidMethodVariadicTestInterfaceWillBeGarbageCollectedA rgMethod(info); 6640 TestObjectV8Internal::voidMethodVariadicTestInterfaceWillBeGarbageCollectedA rgMethod(info);
6369 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 6641 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6370 } 6642 }
6371 6643
6372 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6644 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6373 { 6645 {
6374 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodA", "TestObject", info.Holder(), info.GetIsolate()); 6646 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodA", "TestObject", info.Holder(), info.GetIsolate());
6375 if (UNLIKELY(info.Length() < 1)) { 6647 if (UNLIKELY(info.Length() < 1)) {
6376 throwArityTypeError(exceptionState, 1, info.Length()); 6648 throwArityTypeError(exceptionState, 1, info.Length());
6377 return; 6649 return;
6378 } 6650 }
6379 TestObject* impl = V8TestObject::toNative(info.Holder()); 6651 TestObject* impl = V8TestObject::toNative(info.Holder());
6380 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6652 int longArg;
6653 {
6654 v8::TryCatch block;
6655 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6656 }
6381 impl->overloadedMethodA(longArg); 6657 impl->overloadedMethodA(longArg);
6382 } 6658 }
6383 6659
6384 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6660 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6385 { 6661 {
6386 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodA", "TestObject", info.Holder(), info.GetIsolate()); 6662 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodA", "TestObject", info.Holder(), info.GetIsolate());
6387 if (UNLIKELY(info.Length() < 2)) { 6663 if (UNLIKELY(info.Length() < 2)) {
6388 throwArityTypeError(exceptionState, 2, info.Length()); 6664 throwArityTypeError(exceptionState, 2, info.Length());
6389 return; 6665 return;
6390 } 6666 }
6391 TestObject* impl = V8TestObject::toNative(info.Holder()); 6667 TestObject* impl = V8TestObject::toNative(info.Holder());
6392 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState) , exceptionState); 6668 int longArg1;
6393 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState) , exceptionState); 6669 int longArg2;
6670 {
6671 v8::TryCatch block;
6672 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptio nState), exceptionState);
6673 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptio nState), exceptionState);
6674 }
6394 impl->overloadedMethodA(longArg1, longArg2); 6675 impl->overloadedMethodA(longArg1, longArg2);
6395 } 6676 }
6396 6677
6397 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6678 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6398 { 6679 {
6399 if (((info.Length() == 1))) { 6680 if (((info.Length() == 1))) {
6400 overloadedMethodA1Method(info); 6681 overloadedMethodA1Method(info);
6401 return; 6682 return;
6402 } 6683 }
6403 if (((info.Length() == 2))) { 6684 if (((info.Length() == 2))) {
(...skipping 17 matching lines...) Expand all
6421 } 6702 }
6422 6703
6423 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6704 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6424 { 6705 {
6425 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodB", "TestObject", info.Holder(), info.GetIsolate()); 6706 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodB", "TestObject", info.Holder(), info.GetIsolate());
6426 if (UNLIKELY(info.Length() < 1)) { 6707 if (UNLIKELY(info.Length() < 1)) {
6427 throwArityTypeError(exceptionState, 1, info.Length()); 6708 throwArityTypeError(exceptionState, 1, info.Length());
6428 return; 6709 return;
6429 } 6710 }
6430 TestObject* impl = V8TestObject::toNative(info.Holder()); 6711 TestObject* impl = V8TestObject::toNative(info.Holder());
6431 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6712 int longArg;
6713 {
6714 v8::TryCatch block;
6715 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6716 }
6432 impl->overloadedMethodB(longArg); 6717 impl->overloadedMethodB(longArg);
6433 } 6718 }
6434 6719
6435 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6720 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6436 { 6721 {
6437 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodB", "TestObject", info.Holder(), info.GetIsolate()); 6722 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodB", "TestObject", info.Holder(), info.GetIsolate());
6438 if (UNLIKELY(info.Length() < 1)) { 6723 if (UNLIKELY(info.Length() < 1)) {
6439 throwArityTypeError(exceptionState, 1, info.Length()); 6724 throwArityTypeError(exceptionState, 1, info.Length());
6440 return; 6725 return;
6441 } 6726 }
6442 TestObject* impl = V8TestObject::toNative(info.Holder()); 6727 TestObject* impl = V8TestObject::toNative(info.Holder());
6443 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState) , exceptionState); 6728 int longArg1;
6444 if (UNLIKELY(info.Length() <= 1)) { 6729 int longArg2;
6445 impl->overloadedMethodB(longArg1); 6730 {
6446 return; 6731 v8::TryCatch block;
6732 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptio nState), exceptionState);
6733 if (UNLIKELY(info.Length() <= 1)) {
6734 impl->overloadedMethodB(longArg1);
6735 return;
6736 }
6737 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptio nState), exceptionState);
6447 } 6738 }
6448 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState) , exceptionState);
6449 impl->overloadedMethodB(longArg1, longArg2); 6739 impl->overloadedMethodB(longArg1, longArg2);
6450 } 6740 }
6451 6741
6452 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6742 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6453 { 6743 {
6454 if (((info.Length() == 1))) { 6744 if (((info.Length() == 1))) {
6455 overloadedMethodB1Method(info); 6745 overloadedMethodB1Method(info);
6456 return; 6746 return;
6457 } 6747 }
6458 if (((info.Length() == 1)) || ((info.Length() == 2))) { 6748 if (((info.Length() == 1)) || ((info.Length() == 2))) {
(...skipping 17 matching lines...) Expand all
6476 } 6766 }
6477 6767
6478 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6768 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6479 { 6769 {
6480 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodC", "TestObject", info.Holder(), info.GetIsolate()); 6770 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodC", "TestObject", info.Holder(), info.GetIsolate());
6481 if (UNLIKELY(info.Length() < 1)) { 6771 if (UNLIKELY(info.Length() < 1)) {
6482 throwArityTypeError(exceptionState, 1, info.Length()); 6772 throwArityTypeError(exceptionState, 1, info.Length());
6483 return; 6773 return;
6484 } 6774 }
6485 TestObject* impl = V8TestObject::toNative(info.Holder()); 6775 TestObject* impl = V8TestObject::toNative(info.Holder());
6486 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6776 int longArg;
6777 {
6778 v8::TryCatch block;
6779 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6780 }
6487 impl->overloadedMethodC(longArg); 6781 impl->overloadedMethodC(longArg);
6488 } 6782 }
6489 6783
6490 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6784 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6491 { 6785 {
6492 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodC", "TestObject", info.Holder(), info.GetIsolate()); 6786 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodC", "TestObject", info.Holder(), info.GetIsolate());
6493 if (UNLIKELY(info.Length() < 1)) { 6787 if (UNLIKELY(info.Length() < 1)) {
6494 throwArityTypeError(exceptionState, 1, info.Length()); 6788 throwArityTypeError(exceptionState, 1, info.Length());
6495 return; 6789 return;
6496 } 6790 }
6497 TestObject* impl = V8TestObject::toNative(info.Holder()); 6791 TestObject* impl = V8TestObject::toNative(info.Holder());
6498 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6792 int longArg;
6499 TONATIVE_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1)); 6793 Vector<int> longArgs;
6794 {
6795 v8::TryCatch block;
6796 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6797 TONATIVE_VOID_NO_DECL(longArgs, toNativeArguments<int>(info, 1));
6798 }
6500 impl->overloadedMethodC(longArg, longArgs); 6799 impl->overloadedMethodC(longArg, longArgs);
6501 } 6800 }
6502 6801
6503 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6802 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6504 { 6803 {
6505 if (((info.Length() == 1))) { 6804 if (((info.Length() == 1))) {
6506 overloadedMethodC1Method(info); 6805 overloadedMethodC1Method(info);
6507 return; 6806 return;
6508 } 6807 }
6509 if () { 6808 if () {
(...skipping 17 matching lines...) Expand all
6527 } 6826 }
6528 6827
6529 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6828 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6530 { 6829 {
6531 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodD", "TestObject", info.Holder(), info.GetIsolate()); 6830 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodD", "TestObject", info.Holder(), info.GetIsolate());
6532 if (UNLIKELY(info.Length() < 1)) { 6831 if (UNLIKELY(info.Length() < 1)) {
6533 throwArityTypeError(exceptionState, 1, info.Length()); 6832 throwArityTypeError(exceptionState, 1, info.Length());
6534 return; 6833 return;
6535 } 6834 }
6536 TestObject* impl = V8TestObject::toNative(info.Holder()); 6835 TestObject* impl = V8TestObject::toNative(info.Holder());
6537 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6836 int longArg;
6837 {
6838 v8::TryCatch block;
6839 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6840 }
6538 impl->overloadedMethodD(longArg); 6841 impl->overloadedMethodD(longArg);
6539 } 6842 }
6540 6843
6541 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6844 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6542 { 6845 {
6543 if (UNLIKELY(info.Length() < 1)) { 6846 if (UNLIKELY(info.Length() < 1)) {
6544 throwArityTypeErrorForMethod("overloadedMethodD", "TestObject", 1, info. Length(), info.GetIsolate()); 6847 throwArityTypeErrorForMethod("overloadedMethodD", "TestObject", 1, info. Length(), info.GetIsolate());
6545 return; 6848 return;
6546 } 6849 }
6547 TestObject* impl = V8TestObject::toNative(info.Holder()); 6850 TestObject* impl = V8TestObject::toNative(info.Holder());
6548 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 6851 TestInterfaceEmpty* testInterfaceEmptyArg;
6852 {
6853 v8::TryCatch block;
6854 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
6855 }
6549 impl->overloadedMethodD(testInterfaceEmptyArg); 6856 impl->overloadedMethodD(testInterfaceEmptyArg);
6550 } 6857 }
6551 6858
6552 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6859 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6553 { 6860 {
6554 if (((info.Length() == 1))) { 6861 if (((info.Length() == 1))) {
6555 overloadedMethodD1Method(info); 6862 overloadedMethodD1Method(info);
6556 return; 6863 return;
6557 } 6864 }
6558 if (((info.Length() == 1) && (V8TestInterfaceEmpty::hasInstance(info[0], inf o.GetIsolate())))) { 6865 if (((info.Length() == 1) && (V8TestInterfaceEmpty::hasInstance(info[0], inf o.GetIsolate())))) {
(...skipping 17 matching lines...) Expand all
6576 } 6883 }
6577 6884
6578 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6885 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6579 { 6886 {
6580 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodE", "TestObject", info.Holder(), info.GetIsolate()); 6887 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodE", "TestObject", info.Holder(), info.GetIsolate());
6581 if (UNLIKELY(info.Length() < 1)) { 6888 if (UNLIKELY(info.Length() < 1)) {
6582 throwArityTypeError(exceptionState, 1, info.Length()); 6889 throwArityTypeError(exceptionState, 1, info.Length());
6583 return; 6890 return;
6584 } 6891 }
6585 TestObject* impl = V8TestObject::toNative(info.Holder()); 6892 TestObject* impl = V8TestObject::toNative(info.Holder());
6586 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6893 int longArg;
6894 {
6895 v8::TryCatch block;
6896 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6897 }
6587 impl->overloadedMethodE(longArg); 6898 impl->overloadedMethodE(longArg);
6588 } 6899 }
6589 6900
6590 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6901 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6591 { 6902 {
6592 if (UNLIKELY(info.Length() < 1)) { 6903 if (UNLIKELY(info.Length() < 1)) {
6593 throwArityTypeErrorForMethod("overloadedMethodE", "TestObject", 1, info. Length(), info.GetIsolate()); 6904 throwArityTypeErrorForMethod("overloadedMethodE", "TestObject", 1, info. Length(), info.GetIsolate());
6594 return; 6905 return;
6595 } 6906 }
6596 TestObject* impl = V8TestObject::toNative(info.Holder()); 6907 TestObject* impl = V8TestObject::toNative(info.Holder());
6597 TONATIVE_VOID(Vector<int>, longArrayArg, toNativeArray<int>(info[0], 1, info .GetIsolate())); 6908 Vector<int> longArrayArg;
6909 {
6910 v8::TryCatch block;
6911 TONATIVE_VOID_NO_DECL(longArrayArg, toNativeArray<int>(info[0], 1, info. GetIsolate()));
6912 }
6598 impl->overloadedMethodE(longArrayArg); 6913 impl->overloadedMethodE(longArrayArg);
6599 } 6914 }
6600 6915
6601 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6916 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6602 { 6917 {
6603 if (((info.Length() == 1))) { 6918 if (((info.Length() == 1))) {
6604 overloadedMethodE1Method(info); 6919 overloadedMethodE1Method(info);
6605 return; 6920 return;
6606 } 6921 }
6607 if (((info.Length() == 1) && (info[0]->IsArray()))) { 6922 if (((info.Length() == 1) && (info[0]->IsArray()))) {
(...skipping 17 matching lines...) Expand all
6625 } 6940 }
6626 6941
6627 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6942 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6628 { 6943 {
6629 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodF", "TestObject", info.Holder(), info.GetIsolate()); 6944 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodF", "TestObject", info.Holder(), info.GetIsolate());
6630 if (UNLIKELY(info.Length() < 1)) { 6945 if (UNLIKELY(info.Length() < 1)) {
6631 throwArityTypeError(exceptionState, 1, info.Length()); 6946 throwArityTypeError(exceptionState, 1, info.Length());
6632 return; 6947 return;
6633 } 6948 }
6634 TestObject* impl = V8TestObject::toNative(info.Holder()); 6949 TestObject* impl = V8TestObject::toNative(info.Holder());
6635 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 6950 int longArg;
6951 {
6952 v8::TryCatch block;
6953 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
6954 }
6636 impl->overloadedMethodF(longArg); 6955 impl->overloadedMethodF(longArg);
6637 } 6956 }
6638 6957
6639 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 6958 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6640 { 6959 {
6641 if (UNLIKELY(info.Length() < 1)) { 6960 if (UNLIKELY(info.Length() < 1)) {
6642 throwArityTypeErrorForMethod("overloadedMethodF", "TestObject", 1, info. Length(), info.GetIsolate()); 6961 throwArityTypeErrorForMethod("overloadedMethodF", "TestObject", 1, info. Length(), info.GetIsolate());
6643 return; 6962 return;
6644 } 6963 }
6645 TestObject* impl = V8TestObject::toNative(info.Holder()); 6964 TestObject* impl = V8TestObject::toNative(info.Holder());
6646 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterf aceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 6965 TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
6966 {
6967 v8::TryCatch block;
6968 TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty: :toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6969 }
6647 impl->overloadedMethodF(testInterfaceEmptyOrNullArg); 6970 impl->overloadedMethodF(testInterfaceEmptyOrNullArg);
6648 } 6971 }
6649 6972
6650 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 6973 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6651 { 6974 {
6652 if (((info.Length() == 1))) { 6975 if (((info.Length() == 1))) {
6653 overloadedMethodF1Method(info); 6976 overloadedMethodF1Method(info);
6654 return; 6977 return;
6655 } 6978 }
6656 if (((info.Length() == 1) && (info[0]->IsNull() || V8TestInterfaceEmpty::has Instance(info[0], info.GetIsolate())))) { 6979 if (((info.Length() == 1) && (info[0]->IsNull() || V8TestInterfaceEmpty::has Instance(info[0], info.GetIsolate())))) {
(...skipping 22 matching lines...) Expand all
6679 impl->overloadedMethodG(); 7002 impl->overloadedMethodG();
6680 } 7003 }
6681 7004
6682 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7005 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6683 { 7006 {
6684 if (UNLIKELY(info.Length() < 1)) { 7007 if (UNLIKELY(info.Length() < 1)) {
6685 throwArityTypeErrorForMethod("overloadedMethodG", "TestObject", 1, info. Length(), info.GetIsolate()); 7008 throwArityTypeErrorForMethod("overloadedMethodG", "TestObject", 1, info. Length(), info.GetIsolate());
6686 return; 7009 return;
6687 } 7010 }
6688 TestObject* impl = V8TestObject::toNative(info.Holder()); 7011 TestObject* impl = V8TestObject::toNative(info.Holder());
6689 TOSTRING_VOID(V8StringResource<>, legacyOverloadStringStringArg, info[0]); 7012 V8StringResource<> legacyOverloadStringStringArg;
7013 {
7014 v8::TryCatch block;
7015 TOSTRING_VOID_NO_DECL(legacyOverloadStringStringArg, info[0]);
7016 }
6690 impl->overloadedMethodG(legacyOverloadStringStringArg); 7017 impl->overloadedMethodG(legacyOverloadStringStringArg);
6691 } 7018 }
6692 7019
6693 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 7020 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6694 { 7021 {
6695 if (((info.Length() == 0))) { 7022 if (((info.Length() == 0))) {
6696 overloadedMethodG1Method(info); 7023 overloadedMethodG1Method(info);
6697 return; 7024 return;
6698 } 7025 }
6699 if (((info.Length() == 1) && (isUndefinedOrNull(info[0]) || info[0]->IsStrin g() || info[0]->IsObject()))) { 7026 if (((info.Length() == 1) && (isUndefinedOrNull(info[0]) || info[0]->IsStrin g() || info[0]->IsObject()))) {
(...skipping 16 matching lines...) Expand all
6716 impl->overloadedMethodH(); 7043 impl->overloadedMethodH();
6717 } 7044 }
6718 7045
6719 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7046 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6720 { 7047 {
6721 if (UNLIKELY(info.Length() < 1)) { 7048 if (UNLIKELY(info.Length() < 1)) {
6722 throwArityTypeErrorForMethod("overloadedMethodH", "TestObject", 1, info. Length(), info.GetIsolate()); 7049 throwArityTypeErrorForMethod("overloadedMethodH", "TestObject", 1, info. Length(), info.GetIsolate());
6723 return; 7050 return;
6724 } 7051 }
6725 TestObject* impl = V8TestObject::toNative(info.Holder()); 7052 TestObject* impl = V8TestObject::toNative(info.Holder());
6726 if (info.Length() <= 0 || !info[0]->IsFunction()) { 7053 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
6727 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", " TestObject", "The callback provided as parameter 1 is not a function."), info.Ge tIsolate()); 7054 {
6728 return; 7055 if (info.Length() <= 0 || !info[0]->IsFunction()) {
7056 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH ", "TestObject", "The callback provided as parameter 1 is not a function."), inf o.GetIsolate());
7057 return;
7058 }
7059 testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8 ::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
6729 } 7060 }
6730 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInter face::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(in fo.GetIsolate()));
6731 impl->overloadedMethodH(testCallbackInterfaceArg.release()); 7061 impl->overloadedMethodH(testCallbackInterfaceArg.release());
6732 } 7062 }
6733 7063
6734 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 7064 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6735 { 7065 {
6736 if (((info.Length() == 0))) { 7066 if (((info.Length() == 0))) {
6737 overloadedMethodH1Method(info); 7067 overloadedMethodH1Method(info);
6738 return; 7068 return;
6739 } 7069 }
6740 if (((info.Length() == 1) && (info[0]->IsNull() || info[0]->IsFunction()))) { 7070 if (((info.Length() == 1) && (info[0]->IsNull() || info[0]->IsFunction()))) {
(...skipping 10 matching lines...) Expand all
6751 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7081 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6752 } 7082 }
6753 7083
6754 static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7084 static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6755 { 7085 {
6756 if (UNLIKELY(info.Length() < 1)) { 7086 if (UNLIKELY(info.Length() < 1)) {
6757 throwArityTypeErrorForMethod("overloadedMethodI", "TestObject", 1, info. Length(), info.GetIsolate()); 7087 throwArityTypeErrorForMethod("overloadedMethodI", "TestObject", 1, info. Length(), info.GetIsolate());
6758 return; 7088 return;
6759 } 7089 }
6760 TestObject* impl = V8TestObject::toNative(info.Holder()); 7090 TestObject* impl = V8TestObject::toNative(info.Holder());
6761 TONATIVE_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsolate ())); 7091 Dictionary dictionaryArg;
6762 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) { 7092 {
6763 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodI", " TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate ()); 7093 v8::TryCatch block;
6764 return; 7094 TONATIVE_VOID_NO_DECL(dictionaryArg, Dictionary(info[0], info.GetIsolate ()));
7095 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
7096 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodI ", "TestObject", "parameter 1 ('dictionaryArg') is not an object."), info.GetIso late());
7097 return;
7098 }
6765 } 7099 }
6766 impl->overloadedMethodI(dictionaryArg); 7100 impl->overloadedMethodI(dictionaryArg);
6767 } 7101 }
6768 7102
6769 static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7103 static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6770 { 7104 {
6771 if (UNLIKELY(info.Length() < 1)) { 7105 if (UNLIKELY(info.Length() < 1)) {
6772 throwArityTypeErrorForMethod("overloadedMethodI", "TestObject", 1, info. Length(), info.GetIsolate()); 7106 throwArityTypeErrorForMethod("overloadedMethodI", "TestObject", 1, info. Length(), info.GetIsolate());
6773 return; 7107 return;
6774 } 7108 }
6775 TestObject* impl = V8TestObject::toNative(info.Holder()); 7109 TestObject* impl = V8TestObject::toNative(info.Holder());
6776 TONATIVE_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue()) ); 7110 double doubleArg;
7111 {
7112 v8::TryCatch block;
7113 TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[0]->NumberValu e()));
7114 }
6777 impl->overloadedMethodI(doubleArg); 7115 impl->overloadedMethodI(doubleArg);
6778 } 7116 }
6779 7117
6780 static void overloadedMethodIMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 7118 static void overloadedMethodIMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6781 { 7119 {
6782 if (((info.Length() == 1) && (info[0]->IsObject()))) { 7120 if (((info.Length() == 1) && (info[0]->IsObject()))) {
6783 overloadedMethodI1Method(info); 7121 overloadedMethodI1Method(info);
6784 return; 7122 return;
6785 } 7123 }
6786 if (((info.Length() == 1))) { 7124 if (((info.Length() == 1))) {
(...skipping 17 matching lines...) Expand all
6804 } 7142 }
6805 7143
6806 static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7144 static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6807 { 7145 {
6808 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodJ", "TestObject", info.Holder(), info.GetIsolate()); 7146 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM ethodJ", "TestObject", info.Holder(), info.GetIsolate());
6809 if (UNLIKELY(info.Length() < 1)) { 7147 if (UNLIKELY(info.Length() < 1)) {
6810 throwArityTypeError(exceptionState, 1, info.Length()); 7148 throwArityTypeError(exceptionState, 1, info.Length());
6811 return; 7149 return;
6812 } 7150 }
6813 TestObject* impl = V8TestObject::toNative(info.Holder()); 7151 TestObject* impl = V8TestObject::toNative(info.Holder());
6814 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 7152 int longArg;
7153 {
7154 v8::TryCatch block;
7155 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
7156 }
6815 impl->overloadedMethodJ(longArg); 7157 impl->overloadedMethodJ(longArg);
6816 } 7158 }
6817 7159
6818 static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 7160 static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6819 { 7161 {
6820 if (UNLIKELY(info.Length() < 1)) { 7162 if (UNLIKELY(info.Length() < 1)) {
6821 throwArityTypeErrorForMethod("overloadedMethodJ", "TestObject", 1, info. Length(), info.GetIsolate()); 7163 throwArityTypeErrorForMethod("overloadedMethodJ", "TestObject", 1, info. Length(), info.GetIsolate());
6822 return; 7164 return;
6823 } 7165 }
6824 TestObject* impl = V8TestObject::toNative(info.Holder()); 7166 TestObject* impl = V8TestObject::toNative(info.Holder());
6825 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterf aceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 7167 TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
7168 {
7169 v8::TryCatch block;
7170 TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty: :toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7171 }
6826 impl->overloadedMethodJ(testInterfaceEmptyOrNullArg); 7172 impl->overloadedMethodJ(testInterfaceEmptyOrNullArg);
6827 } 7173 }
6828 7174
6829 static void overloadedMethodJMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo) 7175 static void overloadedMethodJMethod(const v8::FunctionCallbackInfo<v8::Value>& i nfo)
6830 { 7176 {
6831 if (((info.Length() == 1))) { 7177 if (((info.Length() == 1))) {
6832 overloadedMethodJ1Method(info); 7178 overloadedMethodJ1Method(info);
6833 return; 7179 return;
6834 } 7180 }
6835 if (((info.Length() == 1) && (isUndefinedOrNull(info[0]) || V8TestInterfaceE mpty::hasInstance(info[0], info.GetIsolate())))) { 7181 if (((info.Length() == 1) && (isUndefinedOrNull(info[0]) || V8TestInterfaceE mpty::hasInstance(info[0], info.GetIsolate())))) {
(...skipping 29 matching lines...) Expand all
6865 } 7211 }
6866 7212
6867 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn fo<v8::Value>& info) 7213 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn fo<v8::Value>& info)
6868 { 7214 {
6869 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP erWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate()); 7215 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP erWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
6870 if (UNLIKELY(info.Length() < 1)) { 7216 if (UNLIKELY(info.Length() < 1)) {
6871 throwArityTypeError(exceptionState, 1, info.Length()); 7217 throwArityTypeError(exceptionState, 1, info.Length());
6872 return; 7218 return;
6873 } 7219 }
6874 TestObject* impl = V8TestObject::toNative(info.Holder()); 7220 TestObject* impl = V8TestObject::toNative(info.Holder());
6875 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 7221 int longArg;
7222 {
7223 v8::TryCatch block;
7224 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
7225 }
6876 impl->overloadedPerWorldBindingsMethod(longArg); 7226 impl->overloadedPerWorldBindingsMethod(longArg);
6877 } 7227 }
6878 7228
6879 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf o<v8::Value>& info) 7229 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf o<v8::Value>& info)
6880 { 7230 {
6881 if (((info.Length() == 0))) { 7231 if (((info.Length() == 0))) {
6882 overloadedPerWorldBindingsMethod1Method(info); 7232 overloadedPerWorldBindingsMethod1Method(info);
6883 return; 7233 return;
6884 } 7234 }
6885 if (((info.Length() == 1))) { 7235 if (((info.Length() == 1))) {
(...skipping 11 matching lines...) Expand all
6897 } 7247 }
6898 7248
6899 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi onCallbackInfo<v8::Value>& info) 7249 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi onCallbackInfo<v8::Value>& info)
6900 { 7250 {
6901 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP erWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate()); 7251 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP erWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
6902 if (UNLIKELY(info.Length() < 1)) { 7252 if (UNLIKELY(info.Length() < 1)) {
6903 throwArityTypeError(exceptionState, 1, info.Length()); 7253 throwArityTypeError(exceptionState, 1, info.Length());
6904 return; 7254 return;
6905 } 7255 }
6906 TestObject* impl = V8TestObject::toNative(info.Holder()); 7256 TestObject* impl = V8TestObject::toNative(info.Holder());
6907 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 7257 int longArg;
7258 {
7259 v8::TryCatch block;
7260 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
7261 }
6908 impl->overloadedPerWorldBindingsMethod(longArg); 7262 impl->overloadedPerWorldBindingsMethod(longArg);
6909 } 7263 }
6910 7264
6911 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio nCallbackInfo<v8::Value>& info) 7265 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio nCallbackInfo<v8::Value>& info)
6912 { 7266 {
6913 if (((info.Length() == 0))) { 7267 if (((info.Length() == 0))) {
6914 overloadedPerWorldBindingsMethod1MethodForMainWorld(info); 7268 overloadedPerWorldBindingsMethod1MethodForMainWorld(info);
6915 return; 7269 return;
6916 } 7270 }
6917 if (((info.Length() == 1))) { 7271 if (((info.Length() == 1))) {
(...skipping 10 matching lines...) Expand all
6928 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7282 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6929 } 7283 }
6930 7284
6931 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val ue>& info) 7285 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val ue>& info)
6932 { 7286 {
6933 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS taticMethod", "TestObject", info.Holder(), info.GetIsolate()); 7287 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS taticMethod", "TestObject", info.Holder(), info.GetIsolate());
6934 if (UNLIKELY(info.Length() < 1)) { 7288 if (UNLIKELY(info.Length() < 1)) {
6935 throwArityTypeError(exceptionState, 1, info.Length()); 7289 throwArityTypeError(exceptionState, 1, info.Length());
6936 return; 7290 return;
6937 } 7291 }
6938 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 7292 int longArg;
7293 {
7294 v8::TryCatch block;
7295 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
7296 }
6939 TestObject::overloadedStaticMethod(longArg); 7297 TestObject::overloadedStaticMethod(longArg);
6940 } 7298 }
6941 7299
6942 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val ue>& info) 7300 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val ue>& info)
6943 { 7301 {
6944 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS taticMethod", "TestObject", info.Holder(), info.GetIsolate()); 7302 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS taticMethod", "TestObject", info.Holder(), info.GetIsolate());
6945 if (UNLIKELY(info.Length() < 2)) { 7303 if (UNLIKELY(info.Length() < 2)) {
6946 throwArityTypeError(exceptionState, 2, info.Length()); 7304 throwArityTypeError(exceptionState, 2, info.Length());
6947 return; 7305 return;
6948 } 7306 }
6949 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg1, toInt32(info[0], exceptionState) , exceptionState); 7307 int longArg1;
6950 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg2, toInt32(info[1], exceptionState) , exceptionState); 7308 int longArg2;
7309 {
7310 v8::TryCatch block;
7311 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg1, toInt32(info[0], exceptio nState), exceptionState);
7312 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg2, toInt32(info[1], exceptio nState), exceptionState);
7313 }
6951 TestObject::overloadedStaticMethod(longArg1, longArg2); 7314 TestObject::overloadedStaticMethod(longArg1, longArg2);
6952 } 7315 }
6953 7316
6954 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu e>& info) 7317 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu e>& info)
6955 { 7318 {
6956 if (((info.Length() == 1))) { 7319 if (((info.Length() == 1))) {
6957 overloadedStaticMethod1Method(info); 7320 overloadedStaticMethod1Method(info);
6958 return; 7321 return;
6959 } 7322 }
6960 if (((info.Length() == 2))) { 7323 if (((info.Length() == 2))) {
(...skipping 18 matching lines...) Expand all
6979 7342
6980 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info) 7343 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo <v8::Value>& info)
6981 { 7344 {
6982 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC lampUnsignedShortArg", "TestObject", info.Holder(), info.GetIsolate()); 7345 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC lampUnsignedShortArg", "TestObject", info.Holder(), info.GetIsolate());
6983 if (UNLIKELY(info.Length() < 1)) { 7346 if (UNLIKELY(info.Length() < 1)) {
6984 throwArityTypeError(exceptionState, 1, info.Length()); 7347 throwArityTypeError(exceptionState, 1, info.Length());
6985 return; 7348 return;
6986 } 7349 }
6987 TestObject* impl = V8TestObject::toNative(info.Holder()); 7350 TestObject* impl = V8TestObject::toNative(info.Holder());
6988 unsigned clampUnsignedShortArg = 0; 7351 unsigned clampUnsignedShortArg = 0;
6989 TONATIVE_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberValue ()); 7352 {
6990 if (!std::isnan(clampUnsignedShortArgNativeValue)) 7353 v8::TryCatch block;
6991 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNat iveValue); 7354 double clampUnsignedShortArgNativeValue;
7355 TONATIVE_VOID_NO_DECL(clampUnsignedShortArgNativeValue, info[0]->NumberV alue());
7356 if (!std::isnan(clampUnsignedShortArgNativeValue))
7357 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortAr gNativeValue);
7358 }
6992 impl->voidMethodClampUnsignedShortArg(clampUnsignedShortArg); 7359 impl->voidMethodClampUnsignedShortArg(clampUnsignedShortArg);
6993 } 7360 }
6994 7361
6995 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info) 7362 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall backInfo<v8::Value>& info)
6996 { 7363 {
6997 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7364 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6998 TestObjectV8Internal::voidMethodClampUnsignedShortArgMethod(info); 7365 TestObjectV8Internal::voidMethodClampUnsignedShortArgMethod(info);
6999 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7366 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7000 } 7367 }
7001 7368
7002 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo< v8::Value>& info) 7369 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo< v8::Value>& info)
7003 { 7370 {
7004 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC lampUnsignedLongArg", "TestObject", info.Holder(), info.GetIsolate()); 7371 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC lampUnsignedLongArg", "TestObject", info.Holder(), info.GetIsolate());
7005 if (UNLIKELY(info.Length() < 1)) { 7372 if (UNLIKELY(info.Length() < 1)) {
7006 throwArityTypeError(exceptionState, 1, info.Length()); 7373 throwArityTypeError(exceptionState, 1, info.Length());
7007 return; 7374 return;
7008 } 7375 }
7009 TestObject* impl = V8TestObject::toNative(info.Holder()); 7376 TestObject* impl = V8TestObject::toNative(info.Holder());
7010 unsigned clampUnsignedLongArg = 0; 7377 unsigned clampUnsignedLongArg = 0;
7011 TONATIVE_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValue( )); 7378 {
7012 if (!std::isnan(clampUnsignedLongArgNativeValue)) 7379 v8::TryCatch block;
7013 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNative Value); 7380 double clampUnsignedLongArgNativeValue;
7381 TONATIVE_VOID_NO_DECL(clampUnsignedLongArgNativeValue, info[0]->NumberVa lue());
7382 if (!std::isnan(clampUnsignedLongArgNativeValue))
7383 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNa tiveValue);
7384 }
7014 impl->voidMethodClampUnsignedLongArg(clampUnsignedLongArg); 7385 impl->voidMethodClampUnsignedLongArg(clampUnsignedLongArg);
7015 } 7386 }
7016 7387
7017 static void voidMethodClampUnsignedLongArgMethodCallback(const v8::FunctionCallb ackInfo<v8::Value>& info) 7388 static void voidMethodClampUnsignedLongArgMethodCallback(const v8::FunctionCallb ackInfo<v8::Value>& info)
7018 { 7389 {
7019 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7390 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7020 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info); 7391 TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info);
7021 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7392 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7022 } 7393 }
7023 7394
7024 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info) 7395 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info)
7025 { 7396 {
7026 TestObject* impl = V8TestObject::toNative(info.Holder()); 7397 TestObject* impl = V8TestObject::toNative(info.Holder());
7027 TONATIVE_VOID(TestInterfaceEmpty*, defaultUndefinedTestInterfaceEmptyArg, V8 TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 7398 TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg;
7399 {
7400 v8::TryCatch block;
7401 TONATIVE_VOID_NO_DECL(defaultUndefinedTestInterfaceEmptyArg, V8TestInter faceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7402 }
7028 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn terfaceEmptyArg); 7403 impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestIn terfaceEmptyArg);
7029 } 7404 }
7030 7405
7031 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 7406 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7032 { 7407 {
7033 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7408 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7034 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod( info); 7409 TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod( info);
7035 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7410 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7036 } 7411 }
7037 7412
7038 static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackIn fo<v8::Value>& info) 7413 static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackIn fo<v8::Value>& info)
7039 { 7414 {
7040 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD efaultUndefinedLongArg", "TestObject", info.Holder(), info.GetIsolate()); 7415 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD efaultUndefinedLongArg", "TestObject", info.Holder(), info.GetIsolate());
7041 TestObject* impl = V8TestObject::toNative(info.Holder()); 7416 TestObject* impl = V8TestObject::toNative(info.Holder());
7042 TONATIVE_VOID_EXCEPTIONSTATE(int, defaultUndefinedLongArg, toInt32(info[0], exceptionState), exceptionState); 7417 int defaultUndefinedLongArg;
7418 {
7419 v8::TryCatch block;
7420 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(defaultUndefinedLongArg, toInt32(in fo[0], exceptionState), exceptionState);
7421 }
7043 impl->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg); 7422 impl->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg);
7044 } 7423 }
7045 7424
7046 static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCa llbackInfo<v8::Value>& info) 7425 static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCa llbackInfo<v8::Value>& info)
7047 { 7426 {
7048 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7427 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7049 TestObjectV8Internal::voidMethodDefaultUndefinedLongArgMethod(info); 7428 TestObjectV8Internal::voidMethodDefaultUndefinedLongArgMethod(info);
7050 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7429 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7051 } 7430 }
7052 7431
7053 static void voidMethodDefaultUndefinedStringArgMethod(const v8::FunctionCallback Info<v8::Value>& info) 7432 static void voidMethodDefaultUndefinedStringArgMethod(const v8::FunctionCallback Info<v8::Value>& info)
7054 { 7433 {
7055 TestObject* impl = V8TestObject::toNative(info.Holder()); 7434 TestObject* impl = V8TestObject::toNative(info.Holder());
7056 TOSTRING_VOID(V8StringResource<>, defaultUndefinedStringArg, info[0]); 7435 V8StringResource<> defaultUndefinedStringArg;
7436 {
7437 v8::TryCatch block;
7438 TOSTRING_VOID_NO_DECL(defaultUndefinedStringArg, info[0]);
7439 }
7057 impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg); 7440 impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg);
7058 } 7441 }
7059 7442
7060 static void voidMethodDefaultUndefinedStringArgMethodCallback(const v8::Function CallbackInfo<v8::Value>& info) 7443 static void voidMethodDefaultUndefinedStringArgMethodCallback(const v8::Function CallbackInfo<v8::Value>& info)
7061 { 7444 {
7062 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7445 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7063 TestObjectV8Internal::voidMethodDefaultUndefinedStringArgMethod(info); 7446 TestObjectV8Internal::voidMethodDefaultUndefinedStringArgMethod(info);
7064 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7447 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7065 } 7448 }
7066 7449
7067 static void voidMethodDefaultNullStringStringArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info) 7450 static void voidMethodDefaultNullStringStringArgMethod(const v8::FunctionCallbac kInfo<v8::Value>& info)
7068 { 7451 {
7069 TestObject* impl = V8TestObject::toNative(info.Holder()); 7452 TestObject* impl = V8TestObject::toNative(info.Holder());
7070 TOSTRING_VOID(V8StringResource<>, defaultNullStringStringArg, argumentOrNull (info, 0)); 7453 V8StringResource<> defaultNullStringStringArg;
7454 {
7455 v8::TryCatch block;
7456 TOSTRING_VOID_NO_DECL(defaultNullStringStringArg, argumentOrNull(info, 0 ));
7457 }
7071 impl->voidMethodDefaultNullStringStringArg(defaultNullStringStringArg); 7458 impl->voidMethodDefaultNullStringStringArg(defaultNullStringStringArg);
7072 } 7459 }
7073 7460
7074 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info) 7461 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio nCallbackInfo<v8::Value>& info)
7075 { 7462 {
7076 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7463 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7077 TestObjectV8Internal::voidMethodDefaultNullStringStringArgMethod(info); 7464 TestObjectV8Internal::voidMethodDefaultNullStringStringArgMethod(info);
7078 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7465 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7079 } 7466 }
7080 7467
7081 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v 8::Value>& info) 7468 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v 8::Value>& info)
7082 { 7469 {
7083 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodE nforceRangeLongArg", "TestObject", info.Holder(), info.GetIsolate()); 7470 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodE nforceRangeLongArg", "TestObject", info.Holder(), info.GetIsolate());
7084 if (UNLIKELY(info.Length() < 1)) { 7471 if (UNLIKELY(info.Length() < 1)) {
7085 throwArityTypeError(exceptionState, 1, info.Length()); 7472 throwArityTypeError(exceptionState, 1, info.Length());
7086 return; 7473 return;
7087 } 7474 }
7088 TestObject* impl = V8TestObject::toNative(info.Holder()); 7475 TestObject* impl = V8TestObject::toNative(info.Holder());
7089 TONATIVE_VOID_EXCEPTIONSTATE(int, enforceRangeLongArg, toInt32(info[0], Enfo rceRange, exceptionState), exceptionState); 7476 int enforceRangeLongArg;
7477 {
7478 v8::TryCatch block;
7479 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(enforceRangeLongArg, toInt32(info[0 ], EnforceRange, exceptionState), exceptionState);
7480 }
7090 impl->voidMethodEnforceRangeLongArg(enforceRangeLongArg); 7481 impl->voidMethodEnforceRangeLongArg(enforceRangeLongArg);
7091 } 7482 }
7092 7483
7093 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba ckInfo<v8::Value>& info) 7484 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba ckInfo<v8::Value>& info)
7094 { 7485 {
7095 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7486 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7096 TestObjectV8Internal::voidMethodEnforceRangeLongArgMethod(info); 7487 TestObjectV8Internal::voidMethodEnforceRangeLongArgMethod(info);
7097 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7488 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7098 } 7489 }
7099 7490
7100 static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info) 7491 static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info)
7101 { 7492 {
7102 if (UNLIKELY(info.Length() < 1)) { 7493 if (UNLIKELY(info.Length() < 1)) {
7103 throwArityTypeErrorForMethod("voidMethodTreatNullAsNullStringStringArg", "TestObject", 1, info.Length(), info.GetIsolate()); 7494 throwArityTypeErrorForMethod("voidMethodTreatNullAsNullStringStringArg", "TestObject", 1, info.Length(), info.GetIsolate());
7104 return; 7495 return;
7105 } 7496 }
7106 TestObject* impl = V8TestObject::toNative(info.Holder()); 7497 TestObject* impl = V8TestObject::toNative(info.Holder());
7107 TOSTRING_VOID(V8StringResource<WithNullCheck>, treatNullAsNullStringStringAr g, info[0]); 7498 V8StringResource<WithNullCheck> treatNullAsNullStringStringArg;
7499 {
7500 v8::TryCatch block;
7501 TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
7502 }
7108 impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringAr g); 7503 impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringAr g);
7109 } 7504 }
7110 7505
7111 static void voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info) 7506 static void voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info)
7112 { 7507 {
7113 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7508 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7114 TestObjectV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(info); 7509 TestObjectV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(info);
7115 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7510 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7116 } 7511 }
7117 7512
7118 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe thod(const v8::FunctionCallbackInfo<v8::Value>& info) 7513 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe thod(const v8::FunctionCallbackInfo<v8::Value>& info)
7119 { 7514 {
7120 if (UNLIKELY(info.Length() < 1)) { 7515 if (UNLIKELY(info.Length() < 1)) {
7121 throwArityTypeErrorForMethod("voidMethodTreatNullAsNullStringTreatUndefi nedAsNullStringStringArg", "TestObject", 1, info.Length(), info.GetIsolate()); 7516 throwArityTypeErrorForMethod("voidMethodTreatNullAsNullStringTreatUndefi nedAsNullStringStringArg", "TestObject", 1, info.Length(), info.GetIsolate());
7122 return; 7517 return;
7123 } 7518 }
7124 TestObject* impl = V8TestObject::toNative(info.Holder()); 7519 TestObject* impl = V8TestObject::toNative(info.Holder());
7125 TOSTRING_VOID(V8StringResource<WithUndefinedOrNullCheck>, treatNullAsNullStr ingStringArg, info[0]); 7520 V8StringResource<WithUndefinedOrNullCheck> treatNullAsNullStringStringArg;
7521 {
7522 v8::TryCatch block;
7523 TOSTRING_VOID_NO_DECL(treatNullAsNullStringStringArg, info[0]);
7524 }
7126 impl->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(tre atNullAsNullStringStringArg); 7525 impl->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(tre atNullAsNullStringStringArg);
7127 } 7526 }
7128 7527
7129 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 7528 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7130 { 7529 {
7131 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7530 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7132 TestObjectV8Internal::voidMethodTreatNullAsNullStringTreatUndefinedAsNullStr ingStringArgMethod(info); 7531 TestObjectV8Internal::voidMethodTreatNullAsNullStringTreatUndefinedAsNullStr ingStringArgMethod(info);
7133 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7532 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7134 } 7533 }
7135 7534
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
7220 static void callWithScriptStateScriptArgumentsVoidMethodMethodCallback(const v8: :FunctionCallbackInfo<v8::Value>& info) 7619 static void callWithScriptStateScriptArgumentsVoidMethodMethodCallback(const v8: :FunctionCallbackInfo<v8::Value>& info)
7221 { 7620 {
7222 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7621 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7223 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(inf o); 7622 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(inf o);
7224 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7623 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7225 } 7624 }
7226 7625
7227 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod (const v8::FunctionCallbackInfo<v8::Value>& info) 7626 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod (const v8::FunctionCallbackInfo<v8::Value>& info)
7228 { 7627 {
7229 TestObject* impl = V8TestObject::toNative(info.Holder()); 7628 TestObject* impl = V8TestObject::toNative(info.Holder());
7230 if (UNLIKELY(info.Length() <= 0)) { 7629 bool optionalBooleanArg;
7231 ScriptState* state = ScriptState::current(info.GetIsolate()); 7630 {
7232 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1)); 7631 v8::TryCatch block;
7233 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(sta te, scriptArguments.release()); 7632 if (UNLIKELY(info.Length() <= 0)) {
7234 return; 7633 ScriptState* state = ScriptState::current(info.GetIsolate());
7634 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
7635 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg (state, scriptArguments.release());
7636 return;
7637 }
7638 TONATIVE_VOID_NO_DECL(optionalBooleanArg, info[0]->BooleanValue());
7235 } 7639 }
7236 TONATIVE_VOID(bool, optionalBooleanArg, info[0]->BooleanValue());
7237 ScriptState* state = ScriptState::current(info.GetIsolate()); 7640 ScriptState* state = ScriptState::current(info.GetIsolate());
7238 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1)); 7641 RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
7239 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(state, scriptArguments.release(), optionalBooleanArg); 7642 impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(state, scriptArguments.release(), optionalBooleanArg);
7240 } 7643 }
7241 7644
7242 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod Callback(const v8::FunctionCallbackInfo<v8::Value>& info) 7645 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod Callback(const v8::FunctionCallbackInfo<v8::Value>& info)
7243 { 7646 {
7244 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 7647 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7245 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBo oleanArgMethod(info); 7648 TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBo oleanArgMethod(info);
7246 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 7649 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after
7431 } 7834 }
7432 7835
7433 static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8 ::Value>& info) 7836 static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8 ::Value>& info)
7434 { 7837 {
7435 ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAs OverloadedMethod", "TestObject", info.Holder(), info.GetIsolate()); 7838 ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAs OverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
7436 if (UNLIKELY(info.Length() < 1)) { 7839 if (UNLIKELY(info.Length() < 1)) {
7437 throwArityTypeError(exceptionState, 1, info.Length()); 7840 throwArityTypeError(exceptionState, 1, info.Length());
7438 return; 7841 return;
7439 } 7842 }
7440 TestObject* impl = V8TestObject::toNative(info.Holder()); 7843 TestObject* impl = V8TestObject::toNative(info.Holder());
7441 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 7844 int arg;
7845 {
7846 v8::TryCatch block;
7847 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
7848 }
7442 impl->DeprecateAsOverloadedMethod(arg); 7849 impl->DeprecateAsOverloadedMethod(arg);
7443 } 7850 }
7444 7851
7445 static void DeprecateAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8: :Value>& info) 7852 static void DeprecateAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8: :Value>& info)
7446 { 7853 {
7447 if (((info.Length() == 0))) { 7854 if (((info.Length() == 0))) {
7448 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA); 7855 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
7449 DeprecateAsOverloadedMethod1Method(info); 7856 DeprecateAsOverloadedMethod1Method(info);
7450 return; 7857 return;
7451 } 7858 }
(...skipping 19 matching lines...) Expand all
7471 } 7878 }
7472 7879
7473 static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallba ckInfo<v8::Value>& info) 7880 static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallba ckInfo<v8::Value>& info)
7474 { 7881 {
7475 ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAs SameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate()); 7882 ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAs SameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
7476 if (UNLIKELY(info.Length() < 1)) { 7883 if (UNLIKELY(info.Length() < 1)) {
7477 throwArityTypeError(exceptionState, 1, info.Length()); 7884 throwArityTypeError(exceptionState, 1, info.Length());
7478 return; 7885 return;
7479 } 7886 }
7480 TestObject* impl = V8TestObject::toNative(info.Holder()); 7887 TestObject* impl = V8TestObject::toNative(info.Holder());
7481 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 7888 int arg;
7889 {
7890 v8::TryCatch block;
7891 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
7892 }
7482 impl->DeprecateAsSameValueOverloadedMethod(arg); 7893 impl->DeprecateAsSameValueOverloadedMethod(arg);
7483 } 7894 }
7484 7895
7485 static void DeprecateAsSameValueOverloadedMethodMethod(const v8::FunctionCallbac kInfo<v8::Value>& info) 7896 static void DeprecateAsSameValueOverloadedMethodMethod(const v8::FunctionCallbac kInfo<v8::Value>& info)
7486 { 7897 {
7487 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeature); 7898 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeature);
7488 if (((info.Length() == 0))) { 7899 if (((info.Length() == 0))) {
7489 DeprecateAsSameValueOverloadedMethod1Method(info); 7900 DeprecateAsSameValueOverloadedMethod1Method(info);
7490 return; 7901 return;
7491 } 7902 }
(...skipping 18 matching lines...) Expand all
7510 } 7921 }
7511 7922
7512 static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8:: Value>& info) 7923 static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8:: Value>& info)
7513 { 7924 {
7514 ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsOv erloadedMethod", "TestObject", info.Holder(), info.GetIsolate()); 7925 ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsOv erloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
7515 if (UNLIKELY(info.Length() < 1)) { 7926 if (UNLIKELY(info.Length() < 1)) {
7516 throwArityTypeError(exceptionState, 1, info.Length()); 7927 throwArityTypeError(exceptionState, 1, info.Length());
7517 return; 7928 return;
7518 } 7929 }
7519 TestObject* impl = V8TestObject::toNative(info.Holder()); 7930 TestObject* impl = V8TestObject::toNative(info.Holder());
7520 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 7931 int arg;
7932 {
7933 v8::TryCatch block;
7934 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
7935 }
7521 impl->measureAsOverloadedMethod(arg); 7936 impl->measureAsOverloadedMethod(arg);
7522 } 7937 }
7523 7938
7524 static void measureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::V alue>& info) 7939 static void measureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::V alue>& info)
7525 { 7940 {
7526 if (((info.Length() == 0))) { 7941 if (((info.Length() == 0))) {
7527 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter ::TestFeatureA); 7942 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter ::TestFeatureA);
7528 measureAsOverloadedMethod1Method(info); 7943 measureAsOverloadedMethod1Method(info);
7529 return; 7944 return;
7530 } 7945 }
(...skipping 19 matching lines...) Expand all
7550 } 7965 }
7551 7966
7552 static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallback Info<v8::Value>& info) 7967 static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallback Info<v8::Value>& info)
7553 { 7968 {
7554 ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsSa meValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate()); 7969 ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsSa meValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
7555 if (UNLIKELY(info.Length() < 1)) { 7970 if (UNLIKELY(info.Length() < 1)) {
7556 throwArityTypeError(exceptionState, 1, info.Length()); 7971 throwArityTypeError(exceptionState, 1, info.Length());
7557 return; 7972 return;
7558 } 7973 }
7559 TestObject* impl = V8TestObject::toNative(info.Holder()); 7974 TestObject* impl = V8TestObject::toNative(info.Holder());
7560 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 7975 int arg;
7976 {
7977 v8::TryCatch block;
7978 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
7979 }
7561 impl->measureAsSameValueOverloadedMethod(arg); 7980 impl->measureAsSameValueOverloadedMethod(arg);
7562 } 7981 }
7563 7982
7564 static void measureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackI nfo<v8::Value>& info) 7983 static void measureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackI nfo<v8::Value>& info)
7565 { 7984 {
7566 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeature); 7985 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeature);
7567 if (((info.Length() == 0))) { 7986 if (((info.Length() == 0))) {
7568 measureAsSameValueOverloadedMethod1Method(info); 7987 measureAsSameValueOverloadedMethod1Method(info);
7569 return; 7988 return;
7570 } 7989 }
(...skipping 18 matching lines...) Expand all
7589 } 8008 }
7590 8009
7591 static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::Funct ionCallbackInfo<v8::Value>& info) 8010 static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::Funct ionCallbackInfo<v8::Value>& info)
7592 { 8011 {
7593 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs MeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolat e()); 8012 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs MeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolat e());
7594 if (UNLIKELY(info.Length() < 1)) { 8013 if (UNLIKELY(info.Length() < 1)) {
7595 throwArityTypeError(exceptionState, 1, info.Length()); 8014 throwArityTypeError(exceptionState, 1, info.Length());
7596 return; 8015 return;
7597 } 8016 }
7598 TestObject* impl = V8TestObject::toNative(info.Holder()); 8017 TestObject* impl = V8TestObject::toNative(info.Holder());
7599 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 8018 int arg;
8019 {
8020 v8::TryCatch block;
8021 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
8022 }
7600 impl->deprecateAsMeasureAsSameValueOverloadedMethod(arg); 8023 impl->deprecateAsMeasureAsSameValueOverloadedMethod(arg);
7601 } 8024 }
7602 8025
7603 static void deprecateAsMeasureAsSameValueOverloadedMethodMethod(const v8::Functi onCallbackInfo<v8::Value>& info) 8026 static void deprecateAsMeasureAsSameValueOverloadedMethodMethod(const v8::Functi onCallbackInfo<v8::Value>& info)
7604 { 8027 {
7605 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeature); 8028 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeature);
7606 if (((info.Length() == 0))) { 8029 if (((info.Length() == 0))) {
7607 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA); 8030 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
7608 deprecateAsMeasureAsSameValueOverloadedMethod1Method(info); 8031 deprecateAsMeasureAsSameValueOverloadedMethod1Method(info);
7609 return; 8032 return;
(...skipping 20 matching lines...) Expand all
7630 } 8053 }
7631 8054
7632 static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::Funct ionCallbackInfo<v8::Value>& info) 8055 static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::Funct ionCallbackInfo<v8::Value>& info)
7633 { 8056 {
7634 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs SameValueMeasureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolat e()); 8057 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs SameValueMeasureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolat e());
7635 if (UNLIKELY(info.Length() < 1)) { 8058 if (UNLIKELY(info.Length() < 1)) {
7636 throwArityTypeError(exceptionState, 1, info.Length()); 8059 throwArityTypeError(exceptionState, 1, info.Length());
7637 return; 8060 return;
7638 } 8061 }
7639 TestObject* impl = V8TestObject::toNative(info.Holder()); 8062 TestObject* impl = V8TestObject::toNative(info.Holder());
7640 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 8063 int arg;
8064 {
8065 v8::TryCatch block;
8066 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
8067 }
7641 impl->deprecateAsSameValueMeasureAsOverloadedMethod(arg); 8068 impl->deprecateAsSameValueMeasureAsOverloadedMethod(arg);
7642 } 8069 }
7643 8070
7644 static void deprecateAsSameValueMeasureAsOverloadedMethodMethod(const v8::Functi onCallbackInfo<v8::Value>& info) 8071 static void deprecateAsSameValueMeasureAsOverloadedMethodMethod(const v8::Functi onCallbackInfo<v8::Value>& info)
7645 { 8072 {
7646 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeature); 8073 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeature);
7647 if (((info.Length() == 0))) { 8074 if (((info.Length() == 0))) {
7648 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter ::TestFeatureA); 8075 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter ::TestFeatureA);
7649 deprecateAsSameValueMeasureAsOverloadedMethod1Method(info); 8076 deprecateAsSameValueMeasureAsOverloadedMethod1Method(info);
7650 return; 8077 return;
(...skipping 20 matching lines...) Expand all
7671 } 8098 }
7672 8099
7673 static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) 8100 static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
7674 { 8101 {
7675 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs SameValueMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info. GetIsolate()); 8102 ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAs SameValueMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info. GetIsolate());
7676 if (UNLIKELY(info.Length() < 1)) { 8103 if (UNLIKELY(info.Length() < 1)) {
7677 throwArityTypeError(exceptionState, 1, info.Length()); 8104 throwArityTypeError(exceptionState, 1, info.Length());
7678 return; 8105 return;
7679 } 8106 }
7680 TestObject* impl = V8TestObject::toNative(info.Holder()); 8107 TestObject* impl = V8TestObject::toNative(info.Holder());
7681 TONATIVE_VOID_EXCEPTIONSTATE(int, arg, toInt32(info[0], exceptionState), exc eptionState); 8108 int arg;
8109 {
8110 v8::TryCatch block;
8111 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(arg, toInt32(info[0], exceptionStat e), exceptionState);
8112 }
7682 impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod(arg); 8113 impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod(arg);
7683 } 8114 }
7684 8115
7685 static void deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethod(const v 8::FunctionCallbackInfo<v8::Value>& info) 8116 static void deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethod(const v 8::FunctionCallbackInfo<v8::Value>& info)
7686 { 8117 {
7687 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeatureB); 8118 UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::Te stFeatureB);
7688 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeatureA); 8119 UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), Use Counter::TestFeatureA);
7689 if (((info.Length() == 0))) { 8120 if (((info.Length() == 0))) {
7690 deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(info); 8121 deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(info);
7691 return; 8122 return;
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
7756 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8187 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7757 } 8188 }
7758 8189
7759 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info) 8190 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info)
7760 { 8191 {
7761 if (UNLIKELY(info.Length() < 1)) { 8192 if (UNLIKELY(info.Length() < 1)) {
7762 throwArityTypeErrorForMethod("perWorldBindingsVoidMethodTestInterfaceEmp tyArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8193 throwArityTypeErrorForMethod("perWorldBindingsVoidMethodTestInterfaceEmp tyArg", "TestObject", 1, info.Length(), info.GetIsolate());
7763 return; 8194 return;
7764 } 8195 }
7765 TestObject* impl = V8TestObject::toNative(info.Holder()); 8196 TestObject* impl = V8TestObject::toNative(info.Holder());
7766 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 8197 TestInterfaceEmpty* testInterfaceEmptyArg;
8198 {
8199 v8::TryCatch block;
8200 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
8201 }
7767 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg) ; 8202 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg) ;
7768 } 8203 }
7769 8204
7770 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 8205 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7771 { 8206 {
7772 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8207 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7773 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod( info); 8208 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod( info);
7774 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8209 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7775 } 8210 }
7776 8211
7777 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co nst v8::FunctionCallbackInfo<v8::Value>& info) 8212 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co nst v8::FunctionCallbackInfo<v8::Value>& info)
7778 { 8213 {
7779 if (UNLIKELY(info.Length() < 1)) { 8214 if (UNLIKELY(info.Length() < 1)) {
7780 throwArityTypeErrorForMethod("perWorldBindingsVoidMethodTestInterfaceEmp tyArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8215 throwArityTypeErrorForMethod("perWorldBindingsVoidMethodTestInterfaceEmp tyArg", "TestObject", 1, info.Length(), info.GetIsolate());
7781 return; 8216 return;
7782 } 8217 }
7783 TestObject* impl = V8TestObject::toNative(info.Holder()); 8218 TestObject* impl = V8TestObject::toNative(info.Holder());
7784 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 8219 TestInterfaceEmpty* testInterfaceEmptyArg;
8220 {
8221 v8::TryCatch block;
8222 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
8223 }
7785 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg) ; 8224 impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg) ;
7786 } 8225 }
7787 8226
7788 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain World(const v8::FunctionCallbackInfo<v8::Value>& info) 8227 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain World(const v8::FunctionCallbackInfo<v8::Value>& info)
7789 { 8228 {
7790 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8229 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7791 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF orMainWorld(info); 8230 TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodF orMainWorld(info);
7792 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8231 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7793 } 8232 }
7794 8233
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after
7889 { 8328 {
7890 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8329 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7891 TestObjectV8Internal::raisesExceptionStringMethodMethod(info); 8330 TestObjectV8Internal::raisesExceptionStringMethodMethod(info);
7892 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8331 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7893 } 8332 }
7894 8333
7895 static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info) 8334 static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCal lbackInfo<v8::Value>& info)
7896 { 8335 {
7897 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate()); 8336 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodOptionalLongArg", "TestObject", info.Holder(), info.GetIsolate());
7898 TestObject* impl = V8TestObject::toNative(info.Holder()); 8337 TestObject* impl = V8TestObject::toNative(info.Holder());
7899 if (UNLIKELY(info.Length() <= 0)) { 8338 int optionalLongArg;
7900 impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState); 8339 {
7901 if (exceptionState.throwIfNeeded()) 8340 v8::TryCatch block;
8341 if (UNLIKELY(info.Length() <= 0)) {
8342 impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState);
8343 if (exceptionState.throwIfNeeded())
8344 return;
7902 return; 8345 return;
7903 return; 8346 }
8347 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(optionalLongArg, toInt32(info[0], e xceptionState), exceptionState);
7904 } 8348 }
7905 TONATIVE_VOID_EXCEPTIONSTATE(int, optionalLongArg, toInt32(info[0], exceptio nState), exceptionState);
7906 impl->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionSta te); 8349 impl->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionSta te);
7907 if (exceptionState.throwIfNeeded()) 8350 if (exceptionState.throwIfNeeded())
7908 return; 8351 return;
7909 } 8352 }
7910 8353
7911 static void raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info) 8354 static void raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::Fun ctionCallbackInfo<v8::Value>& info)
7912 { 8355 {
7913 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8356 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7914 TestObjectV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(info); 8357 TestObjectV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(info);
7915 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8358 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7916 } 8359 }
7917 8360
7918 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::Fu nctionCallbackInfo<v8::Value>& info) 8361 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::Fu nctionCallbackInfo<v8::Value>& info)
7919 { 8362 {
7920 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodTestCallbackInterfaceArg", "TestObject", info.Holder(), info.GetIs olate()); 8363 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodTestCallbackInterfaceArg", "TestObject", info.Holder(), info.GetIs olate());
7921 if (UNLIKELY(info.Length() < 1)) { 8364 if (UNLIKELY(info.Length() < 1)) {
7922 throwArityTypeError(exceptionState, 1, info.Length()); 8365 throwArityTypeError(exceptionState, 1, info.Length());
7923 return; 8366 return;
7924 } 8367 }
7925 TestObject* impl = V8TestObject::toNative(info.Holder()); 8368 TestObject* impl = V8TestObject::toNative(info.Holder());
7926 if (info.Length() <= 0 || !info[0]->IsFunction()) { 8369 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg;
7927 exceptionState.throwTypeError("The callback provided as parameter 1 is n ot a function."); 8370 {
7928 exceptionState.throwIfNeeded(); 8371 if (info.Length() <= 0 || !info[0]->IsFunction()) {
7929 return; 8372 exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
8373 exceptionState.throwIfNeeded();
8374 return;
8375 }
8376 testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8 ::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
7930 } 8377 }
7931 OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInter face::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(in fo.GetIsolate()));
7932 impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfac eArg.release(), exceptionState); 8378 impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfac eArg.release(), exceptionState);
7933 if (exceptionState.throwIfNeeded()) 8379 if (exceptionState.throwIfNeeded())
7934 return; 8380 return;
7935 } 8381 }
7936 8382
7937 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback(cons t v8::FunctionCallbackInfo<v8::Value>& info) 8383 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback(cons t v8::FunctionCallbackInfo<v8::Value>& info)
7938 { 8384 {
7939 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8385 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7940 TestObjectV8Internal::raisesExceptionVoidMethodTestCallbackInterfaceArgMetho d(info); 8386 TestObjectV8Internal::raisesExceptionVoidMethodTestCallbackInterfaceArgMetho d(info);
7941 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8387 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7942 } 8388 }
7943 8389
7944 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(cons t v8::FunctionCallbackInfo<v8::Value>& info) 8390 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(cons t v8::FunctionCallbackInfo<v8::Value>& info)
7945 { 8391 {
7946 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodOptionalTestCallbackInterfaceArg", "TestObject", info.Holder(), in fo.GetIsolate()); 8392 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep tionVoidMethodOptionalTestCallbackInterfaceArg", "TestObject", info.Holder(), in fo.GetIsolate());
7947 TestObject* impl = V8TestObject::toNative(info.Holder()); 8393 TestObject* impl = V8TestObject::toNative(info.Holder());
7948 OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg; 8394 OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
7949 if (info.Length() > 0 && !isUndefinedOrNull(info[0])) { 8395 {
7950 if (!info[0]->IsFunction()) { 8396 if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
7951 exceptionState.throwTypeError("The callback provided as parameter 1 is not a function."); 8397 if (!info[0]->IsFunction()) {
7952 exceptionState.throwIfNeeded(); 8398 exceptionState.throwTypeError("The callback provided as paramete r 1 is not a function.");
7953 return; 8399 exceptionState.throwIfNeeded();
8400 return;
8401 }
8402 optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v 8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate( )));
7954 } 8403 }
7955 optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::H andle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
7956 } 8404 }
7957 impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTest CallbackInterfaceArg.release(), exceptionState); 8405 impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTest CallbackInterfaceArg.release(), exceptionState);
7958 if (exceptionState.throwIfNeeded()) 8406 if (exceptionState.throwIfNeeded())
7959 return; 8407 return;
7960 } 8408 }
7961 8409
7962 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallb ack(const v8::FunctionCallbackInfo<v8::Value>& info) 8410 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallb ack(const v8::FunctionCallbackInfo<v8::Value>& info)
7963 { 8411 {
7964 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8412 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7965 TestObjectV8Internal::raisesExceptionVoidMethodOptionalTestCallbackInterface ArgMethod(info); 8413 TestObjectV8Internal::raisesExceptionVoidMethodOptionalTestCallbackInterface ArgMethod(info);
(...skipping 18 matching lines...) Expand all
7984 } 8432 }
7985 8433
7986 static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 8434 static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7987 { 8435 {
7988 ExceptionState exceptionState(ExceptionState::ExecutionContext, "callWithExe cutionContextRaisesExceptionVoidMethodLongArg", "TestObject", info.Holder(), inf o.GetIsolate()); 8436 ExceptionState exceptionState(ExceptionState::ExecutionContext, "callWithExe cutionContextRaisesExceptionVoidMethodLongArg", "TestObject", info.Holder(), inf o.GetIsolate());
7989 if (UNLIKELY(info.Length() < 1)) { 8437 if (UNLIKELY(info.Length() < 1)) {
7990 throwArityTypeError(exceptionState, 1, info.Length()); 8438 throwArityTypeError(exceptionState, 1, info.Length());
7991 return; 8439 return;
7992 } 8440 }
7993 TestObject* impl = V8TestObject::toNative(info.Holder()); 8441 TestObject* impl = V8TestObject::toNative(info.Holder());
7994 TONATIVE_VOID_EXCEPTIONSTATE(int, longArg, toInt32(info[0], exceptionState), exceptionState); 8442 int longArg;
8443 {
8444 v8::TryCatch block;
8445 TONATIVE_VOID_EXCEPTIONSTATE_NO_DECL(longArg, toInt32(info[0], exception State), exceptionState);
8446 }
7995 ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate()) ; 8447 ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate()) ;
7996 impl->callWithExecutionContextRaisesExceptionVoidMethodLongArg(scriptContext , longArg, exceptionState); 8448 impl->callWithExecutionContextRaisesExceptionVoidMethodLongArg(scriptContext , longArg, exceptionState);
7997 if (exceptionState.throwIfNeeded()) 8449 if (exceptionState.throwIfNeeded())
7998 return; 8450 return;
7999 } 8451 }
8000 8452
8001 static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info) 8453 static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info)
8002 { 8454 {
8003 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8455 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8004 TestObjectV8Internal::callWithExecutionContextRaisesExceptionVoidMethodLongA rgMethod(info); 8456 TestObjectV8Internal::callWithExecutionContextRaisesExceptionVoidMethodLongA rgMethod(info);
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
8096 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8548 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8097 } 8549 }
8098 8550
8099 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8: :FunctionCallbackInfo<v8::Value>& info) 8551 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8: :FunctionCallbackInfo<v8::Value>& info)
8100 { 8552 {
8101 if (UNLIKELY(info.Length() < 1)) { 8553 if (UNLIKELY(info.Length() < 1)) {
8102 throwArityTypeErrorForMethod("typeCheckingInterfaceVoidMethodTestInterfa ceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8554 throwArityTypeErrorForMethod("typeCheckingInterfaceVoidMethodTestInterfa ceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate());
8103 return; 8555 return;
8104 } 8556 }
8105 TestObject* impl = V8TestObject::toNative(info.Holder()); 8557 TestObject* impl = V8TestObject::toNative(info.Holder());
8106 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], info.Ge tIsolate())) { 8558 TestInterfaceEmpty* testInterfaceEmptyArg;
8107 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterface VoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'Tes tInterfaceEmpty'."), info.GetIsolate()); 8559 {
8108 return; 8560 v8::TryCatch block;
8561 if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], inf o.GetIsolate())) {
8562 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInter faceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
8563 return;
8564 }
8565 TONATIVE_VOID_NO_DECL(testInterfaceEmptyArg, V8TestInterfaceEmpty::toNat iveWithTypeCheck(info.GetIsolate(), info[0]));
8109 } 8566 }
8110 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmp ty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
8111 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt yArg); 8567 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmpt yArg);
8112 } 8568 }
8113 8569
8114 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c onst v8::FunctionCallbackInfo<v8::Value>& info) 8570 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c onst v8::FunctionCallbackInfo<v8::Value>& info)
8115 { 8571 {
8116 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8572 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8117 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe thod(info); 8573 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe thod(info);
8118 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8574 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8119 } 8575 }
8120 8576
8121 static void typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArgMethod(cons t v8::FunctionCallbackInfo<v8::Value>& info) 8577 static void typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArgMethod(cons t v8::FunctionCallbackInfo<v8::Value>& info)
8122 { 8578 {
8123 if (UNLIKELY(info.Length() < 1)) { 8579 if (UNLIKELY(info.Length() < 1)) {
8124 throwArityTypeErrorForMethod("typeCheckingNullableVoidMethodTestInterfac eEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8580 throwArityTypeErrorForMethod("typeCheckingNullableVoidMethodTestInterfac eEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate());
8125 return; 8581 return;
8126 } 8582 }
8127 TestObject* impl = V8TestObject::toNative(info.Holder()); 8583 TestObject* impl = V8TestObject::toNative(info.Holder());
8128 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterf aceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0])); 8584 TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
8585 {
8586 v8::TryCatch block;
8587 TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty: :toNativeWithTypeCheck(info.GetIsolate(), info[0]));
8588 }
8129 impl->typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArg(testInterfac eEmptyOrNullArg); 8589 impl->typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArg(testInterfac eEmptyOrNullArg);
8130 } 8590 }
8131 8591
8132 static void typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArgMethodCallb ack(const v8::FunctionCallbackInfo<v8::Value>& info) 8592 static void typeCheckingNullableVoidMethodTestInterfaceEmptyOrNullArgMethodCallb ack(const v8::FunctionCallbackInfo<v8::Value>& info)
8133 { 8593 {
8134 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8594 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8135 TestObjectV8Internal::typeCheckingNullableVoidMethodTestInterfaceEmptyOrNull ArgMethod(info); 8595 TestObjectV8Internal::typeCheckingNullableVoidMethodTestInterfaceEmptyOrNull ArgMethod(info);
8136 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8596 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8137 } 8597 }
8138 8598
8139 static void typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArgMe thod(const v8::FunctionCallbackInfo<v8::Value>& info) 8599 static void typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArgMe thod(const v8::FunctionCallbackInfo<v8::Value>& info)
8140 { 8600 {
8141 if (UNLIKELY(info.Length() < 1)) { 8601 if (UNLIKELY(info.Length() < 1)) {
8142 throwArityTypeErrorForMethod("typeCheckingInterfaceNullableVoidMethodTes tInterfaceEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8602 throwArityTypeErrorForMethod("typeCheckingInterfaceNullableVoidMethodTes tInterfaceEmptyOrNullArg", "TestObject", 1, info.Length(), info.GetIsolate());
8143 return; 8603 return;
8144 } 8604 }
8145 TestObject* impl = V8TestObject::toNative(info.Holder()); 8605 TestObject* impl = V8TestObject::toNative(info.Holder());
8146 if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpt y::hasInstance(info[0], info.GetIsolate())) { 8606 TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
8147 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterface NullableVoidMethodTestInterfaceEmptyOrNullArg", "TestObject", "parameter 1 is no t of type 'TestInterfaceEmpty'."), info.GetIsolate()); 8607 {
8148 return; 8608 v8::TryCatch block;
8609 if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterface Empty::hasInstance(info[0], info.GetIsolate())) {
8610 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInter faceNullableVoidMethodTestInterfaceEmptyOrNullArg", "TestObject", "parameter 1 i s not of type 'TestInterfaceEmpty'."), info.GetIsolate());
8611 return;
8612 }
8613 TONATIVE_VOID_NO_DECL(testInterfaceEmptyOrNullArg, V8TestInterfaceEmpty: :toNativeWithTypeCheck(info.GetIsolate(), info[0]));
8149 } 8614 }
8150 TONATIVE_VOID(TestInterfaceEmpty*, testInterfaceEmptyOrNullArg, V8TestInterf aceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
8151 impl->typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArg(tes tInterfaceEmptyOrNullArg); 8615 impl->typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArg(tes tInterfaceEmptyOrNullArg);
8152 } 8616 }
8153 8617
8154 static void typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArgMe thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 8618 static void typeCheckingInterfaceNullableVoidMethodTestInterfaceEmptyOrNullArgMe thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
8155 { 8619 {
8156 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8620 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8157 TestObjectV8Internal::typeCheckingInterfaceNullableVoidMethodTestInterfaceEm ptyOrNullArgMethod(info); 8621 TestObjectV8Internal::typeCheckingInterfaceNullableVoidMethodTestInterfaceEm ptyOrNullArgMethod(info);
8158 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8622 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8159 } 8623 }
8160 8624
8161 static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethod(const v8:: FunctionCallbackInfo<v8::Value>& info) 8625 static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethod(const v8:: FunctionCallbackInfo<v8::Value>& info)
8162 { 8626 {
8163 if (UNLIKELY(info.Length() < 2)) { 8627 if (UNLIKELY(info.Length() < 2)) {
8164 throwArityTypeErrorForMethod("typeCheckingUnrestrictedVoidMethodFloatArg DoubleArg", "TestObject", 2, info.Length(), info.GetIsolate()); 8628 throwArityTypeErrorForMethod("typeCheckingUnrestrictedVoidMethodFloatArg DoubleArg", "TestObject", 2, info.Length(), info.GetIsolate());
8165 return; 8629 return;
8166 } 8630 }
8167 TestObject* impl = V8TestObject::toNative(info.Holder()); 8631 TestObject* impl = V8TestObject::toNative(info.Holder());
8168 TONATIVE_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue())); 8632 float floatArg;
8169 if (!std::isfinite(floatArg)) { 8633 double doubleArg;
8170 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestric tedVoidMethodFloatArgDoubleArg", "TestObject", "float parameter 1 is non-finite. "), info.GetIsolate()); 8634 {
8171 return; 8635 v8::TryCatch block;
8172 } 8636 TONATIVE_VOID_NO_DECL(floatArg, static_cast<float>(info[0]->NumberValue( )));
8173 TONATIVE_VOID(double, doubleArg, static_cast<double>(info[1]->NumberValue()) ); 8637 if (!std::isfinite(floatArg)) {
8174 if (!std::isfinite(doubleArg)) { 8638 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnres trictedVoidMethodFloatArgDoubleArg", "TestObject", "float parameter 1 is non-fin ite."), info.GetIsolate());
8175 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnrestric tedVoidMethodFloatArgDoubleArg", "TestObject", "double parameter 2 is non-finite ."), info.GetIsolate()); 8639 return;
8176 return; 8640 }
8641 TONATIVE_VOID_NO_DECL(doubleArg, static_cast<double>(info[1]->NumberValu e()));
8642 if (!std::isfinite(doubleArg)) {
8643 throwTypeError(ExceptionMessages::failedToExecute("typeCheckingUnres trictedVoidMethodFloatArgDoubleArg", "TestObject", "double parameter 2 is non-fi nite."), info.GetIsolate());
8644 return;
8645 }
8177 } 8646 }
8178 impl->typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg(floatArg, doubleAr g); 8647 impl->typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg(floatArg, doubleAr g);
8179 } 8648 }
8180 8649
8181 static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethodCallback(co nst v8::FunctionCallbackInfo<v8::Value>& info) 8650 static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethodCallback(co nst v8::FunctionCallbackInfo<v8::Value>& info)
8182 { 8651 {
8183 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8652 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8184 TestObjectV8Internal::typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMet hod(info); 8653 TestObjectV8Internal::typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMet hod(info);
8185 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8654 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8186 } 8655 }
(...skipping 11 matching lines...) Expand all
8198 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8667 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8199 } 8668 }
8200 8669
8201 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::F unctionCallbackInfo<v8::Value>& info) 8670 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::F unctionCallbackInfo<v8::Value>& info)
8202 { 8671 {
8203 if (UNLIKELY(info.Length() < 1)) { 8672 if (UNLIKELY(info.Length() < 1)) {
8204 throwArityTypeErrorForMethod("voidMethodTestInterfaceGarbageCollectedSeq uenceArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8673 throwArityTypeErrorForMethod("voidMethodTestInterfaceGarbageCollectedSeq uenceArg", "TestObject", 1, info.Length(), info.GetIsolate());
8205 return; 8674 return;
8206 } 8675 }
8207 TestObject* impl = V8TestObject::toNative(info.Holder()); 8676 TestObject* impl = V8TestObject::toNative(info.Holder());
8208 TONATIVE_VOID(HeapVector<Member<TestInterfaceGarbageCollected> >, testInterf aceGarbageCollectedSequenceArg, (toMemberNativeArray<TestInterfaceGarbageCollect ed, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate()))); 8677 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle ctedSequenceArg;
8678 {
8679 v8::TryCatch block;
8680 TONATIVE_VOID_NO_DECL(testInterfaceGarbageCollectedSequenceArg, (toMembe rNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(inf o[0], 1, info.GetIsolate())));
8681 }
8209 impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbag eCollectedSequenceArg); 8682 impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbag eCollectedSequenceArg);
8210 } 8683 }
8211 8684
8212 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback(con st v8::FunctionCallbackInfo<v8::Value>& info) 8685 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback(con st v8::FunctionCallbackInfo<v8::Value>& info)
8213 { 8686 {
8214 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8687 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8215 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMeth od(info); 8688 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMeth od(info);
8216 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8689 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8217 } 8690 }
8218 8691
8219 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info) 8692 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::Func tionCallbackInfo<v8::Value>& info)
8220 { 8693 {
8221 if (UNLIKELY(info.Length() < 1)) { 8694 if (UNLIKELY(info.Length() < 1)) {
8222 throwArityTypeErrorForMethod("voidMethodTestInterfaceGarbageCollectedArr ayArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8695 throwArityTypeErrorForMethod("voidMethodTestInterfaceGarbageCollectedArr ayArg", "TestObject", 1, info.Length(), info.GetIsolate());
8223 return; 8696 return;
8224 } 8697 }
8225 TestObject* impl = V8TestObject::toNative(info.Holder()); 8698 TestObject* impl = V8TestObject::toNative(info.Holder());
8226 TONATIVE_VOID(HeapVector<Member<TestInterfaceGarbageCollected> >, testInterf aceGarbageCollectedArrayArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0], 1, info.GetIsolate()))); 8699 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle ctedArrayArg;
8700 {
8701 v8::TryCatch block;
8702 TONATIVE_VOID_NO_DECL(testInterfaceGarbageCollectedArrayArg, (toMemberNa tiveArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[0 ], 1, info.GetIsolate())));
8703 }
8227 impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCo llectedArrayArg); 8704 impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCo llectedArrayArg);
8228 } 8705 }
8229 8706
8230 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) 8707 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
8231 { 8708 {
8232 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8709 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8233 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethod( info); 8710 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethod( info);
8234 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8711 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8235 } 8712 }
8236 8713
8237 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) 8714 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
8238 { 8715 {
8239 if (UNLIKELY(info.Length() < 1)) { 8716 if (UNLIKELY(info.Length() < 1)) {
8240 throwArityTypeErrorForMethod("voidMethodTestInterfaceWillBeGarbageCollec tedSequenceArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8717 throwArityTypeErrorForMethod("voidMethodTestInterfaceWillBeGarbageCollec tedSequenceArg", "TestObject", 1, info.Length(), info.GetIsolate());
8241 return; 8718 return;
8242 } 8719 }
8243 TestObject* impl = V8TestObject::toNative(info.Holder()); 8720 TestObject* impl = V8TestObject::toNative(info.Holder());
8244 TONATIVE_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbage Collected> >, testInterfaceWillBeGarbageCollectedSequenceArg, (toRefPtrWillBeMem berNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbage Collected>(info[0], 1, info.GetIsolate()))); 8721 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t estInterfaceWillBeGarbageCollectedSequenceArg;
8722 {
8723 v8::TryCatch block;
8724 TONATIVE_VOID_NO_DECL(testInterfaceWillBeGarbageCollectedSequenceArg, (t oRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterf aceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
8725 }
8245 impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterface WillBeGarbageCollectedSequenceArg); 8726 impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterface WillBeGarbageCollectedSequenceArg);
8246 } 8727 }
8247 8728
8248 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info) 8729 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallba ck(const v8::FunctionCallbackInfo<v8::Value>& info)
8249 { 8730 {
8250 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8731 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8251 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceA rgMethod(info); 8732 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceA rgMethod(info);
8252 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8733 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8253 } 8734 }
8254 8735
8255 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8 ::FunctionCallbackInfo<v8::Value>& info) 8736 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8 ::FunctionCallbackInfo<v8::Value>& info)
8256 { 8737 {
8257 if (UNLIKELY(info.Length() < 1)) { 8738 if (UNLIKELY(info.Length() < 1)) {
8258 throwArityTypeErrorForMethod("voidMethodTestInterfaceWillBeGarbageCollec tedArrayArg", "TestObject", 1, info.Length(), info.GetIsolate()); 8739 throwArityTypeErrorForMethod("voidMethodTestInterfaceWillBeGarbageCollec tedArrayArg", "TestObject", 1, info.Length(), info.GetIsolate());
8259 return; 8740 return;
8260 } 8741 }
8261 TestObject* impl = V8TestObject::toNative(info.Holder()); 8742 TestObject* impl = V8TestObject::toNative(info.Holder());
8262 TONATIVE_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbage Collected> >, testInterfaceWillBeGarbageCollectedArrayArg, (toRefPtrWillBeMember NativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCol lected>(info[0], 1, info.GetIsolate()))); 8743 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t estInterfaceWillBeGarbageCollectedArrayArg;
8744 {
8745 v8::TryCatch block;
8746 TONATIVE_VOID_NO_DECL(testInterfaceWillBeGarbageCollectedArrayArg, (toRe fPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterface WillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
8747 }
8263 impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWil lBeGarbageCollectedArrayArg); 8748 impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWil lBeGarbageCollectedArrayArg);
8264 } 8749 }
8265 8750
8266 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback( const v8::FunctionCallbackInfo<v8::Value>& info) 8751 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback( const v8::FunctionCallbackInfo<v8::Value>& info)
8267 { 8752 {
8268 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 8753 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
8269 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgM ethod(info); 8754 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgM ethod(info);
8270 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution"); 8755 TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
8271 } 8756 }
8272 8757
(...skipping 504 matching lines...) Expand 10 before | Expand all | Expand 10 after
8777 fromInternalPointer(object)->deref(); 9262 fromInternalPointer(object)->deref();
8778 } 9263 }
8779 9264
8780 template<> 9265 template<>
8781 v8::Handle<v8::Value> toV8NoInline(TestObject* impl, v8::Handle<v8::Object> crea tionContext, v8::Isolate* isolate) 9266 v8::Handle<v8::Value> toV8NoInline(TestObject* impl, v8::Handle<v8::Object> crea tionContext, v8::Isolate* isolate)
8782 { 9267 {
8783 return toV8(impl, creationContext, isolate); 9268 return toV8(impl, creationContext, isolate);
8784 } 9269 }
8785 9270
8786 } // namespace WebCore 9271 } // namespace WebCore
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698