OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY! | 5 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY! |
6 | 6 |
7 #include "config.h" | 7 #include "config.h" |
8 #include "V8TestObject.h" | 8 #include "V8TestObject.h" |
9 | 9 |
10 #include "bindings/core/v8/BindingSecurity.h" | 10 #include "bindings/core/v8/BindingSecurity.h" |
(...skipping 1436 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1447 static void stringArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) | 1447 static void stringArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) |
1448 { | 1448 { |
1449 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1449 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1450 TestObjectV8Internal::stringArrayAttributeAttributeGetter(info); | 1450 TestObjectV8Internal::stringArrayAttributeAttributeGetter(info); |
1451 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1451 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1452 } | 1452 } |
1453 | 1453 |
1454 static void stringArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) | 1454 static void stringArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) |
1455 { | 1455 { |
1456 v8::Handle<v8::Object> holder = info.Holder(); | 1456 v8::Handle<v8::Object> holder = info.Holder(); |
| 1457 ExceptionState exceptionState(ExceptionState::SetterContext, "stringArrayAtt
ribute", "TestObject", holder, info.GetIsolate()); |
1457 TestObject* impl = V8TestObject::toImpl(holder); | 1458 TestObject* impl = V8TestObject::toImpl(holder); |
1458 TONATIVE_VOID(Vector<String>, cppValue, toImplArray<String>(v8Value, 0, info
.GetIsolate())); | 1459 TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, cppValue, toImplArray<String>(v
8Value, 0, info.GetIsolate(), exceptionState), exceptionState); |
1459 impl->setStringArrayAttribute(cppValue); | 1460 impl->setStringArrayAttribute(cppValue); |
1460 } | 1461 } |
1461 | 1462 |
1462 static void stringArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1463 static void stringArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1463 { | 1464 { |
1464 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1465 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1465 TestObjectV8Internal::stringArrayAttributeAttributeSetter(v8Value, info); | 1466 TestObjectV8Internal::stringArrayAttributeAttributeSetter(v8Value, info); |
1466 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1467 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1467 } | 1468 } |
1468 | 1469 |
1469 static void testInterfaceEmptyArrayAttributeAttributeGetter(const v8::PropertyCa
llbackInfo<v8::Value>& info) | 1470 static void testInterfaceEmptyArrayAttributeAttributeGetter(const v8::PropertyCa
llbackInfo<v8::Value>& info) |
1470 { | 1471 { |
1471 v8::Handle<v8::Object> holder = info.Holder(); | 1472 v8::Handle<v8::Object> holder = info.Holder(); |
1472 TestObject* impl = V8TestObject::toImpl(holder); | 1473 TestObject* impl = V8TestObject::toImpl(holder); |
1473 v8SetReturnValue(info, v8Array(impl->testInterfaceEmptyArrayAttribute(), inf
o.Holder(), info.GetIsolate())); | 1474 v8SetReturnValue(info, v8Array(impl->testInterfaceEmptyArrayAttribute(), inf
o.Holder(), info.GetIsolate())); |
1474 } | 1475 } |
1475 | 1476 |
1476 static void testInterfaceEmptyArrayAttributeAttributeGetterCallback(v8::Local<v8
::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1477 static void testInterfaceEmptyArrayAttributeAttributeGetterCallback(v8::Local<v8
::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1477 { | 1478 { |
1478 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1479 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1479 TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeGetter(info); | 1480 TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeGetter(info); |
1480 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1481 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1481 } | 1482 } |
1482 | 1483 |
1483 static void testInterfaceEmptyArrayAttributeAttributeSetter(v8::Local<v8::Value>
v8Value, const v8::PropertyCallbackInfo<void>& info) | 1484 static void testInterfaceEmptyArrayAttributeAttributeSetter(v8::Local<v8::Value>
v8Value, const v8::PropertyCallbackInfo<void>& info) |
1484 { | 1485 { |
1485 v8::Handle<v8::Object> holder = info.Holder(); | 1486 v8::Handle<v8::Object> holder = info.Holder(); |
| 1487 ExceptionState exceptionState(ExceptionState::SetterContext, "testInterfaceE
mptyArrayAttribute", "TestObject", holder, info.GetIsolate()); |
1486 TestObject* impl = V8TestObject::toImpl(holder); | 1488 TestObject* impl = V8TestObject::toImpl(holder); |
1487 TONATIVE_VOID(Vector<RefPtr<TestInterfaceEmpty> >, cppValue, (toRefPtrNative
Array<TestInterfaceEmpty, V8TestInterfaceEmpty>(v8Value, 0, info.GetIsolate())))
; | 1489 TONATIVE_VOID_EXCEPTIONSTATE(Vector<RefPtr<TestInterfaceEmpty> >, cppValue,
(toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(v8Value, 0, info.
GetIsolate(), exceptionState)), exceptionState); |
1488 impl->setTestInterfaceEmptyArrayAttribute(cppValue); | 1490 impl->setTestInterfaceEmptyArrayAttribute(cppValue); |
1489 } | 1491 } |
1490 | 1492 |
1491 static void testInterfaceEmptyArrayAttributeAttributeSetterCallback(v8::Local<v8
::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& i
nfo) | 1493 static void testInterfaceEmptyArrayAttributeAttributeSetterCallback(v8::Local<v8
::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& i
nfo) |
1492 { | 1494 { |
1493 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1495 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1494 TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeSetter(v8Valu
e, info); | 1496 TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeSetter(v8Valu
e, info); |
1495 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1497 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1496 } | 1498 } |
1497 | 1499 |
1498 static void floatArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) | 1500 static void floatArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8
::Value>& info) |
1499 { | 1501 { |
1500 v8::Handle<v8::Object> holder = info.Holder(); | 1502 v8::Handle<v8::Object> holder = info.Holder(); |
1501 TestObject* impl = V8TestObject::toImpl(holder); | 1503 TestObject* impl = V8TestObject::toImpl(holder); |
1502 v8SetReturnValue(info, v8Array(impl->floatArrayAttribute(), info.Holder(), i
nfo.GetIsolate())); | 1504 v8SetReturnValue(info, v8Array(impl->floatArrayAttribute(), info.Holder(), i
nfo.GetIsolate())); |
1503 } | 1505 } |
1504 | 1506 |
1505 static void floatArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 1507 static void floatArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
1506 { | 1508 { |
1507 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1509 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1508 TestObjectV8Internal::floatArrayAttributeAttributeGetter(info); | 1510 TestObjectV8Internal::floatArrayAttributeAttributeGetter(info); |
1509 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1511 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1510 } | 1512 } |
1511 | 1513 |
1512 static void floatArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) | 1514 static void floatArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con
st v8::PropertyCallbackInfo<void>& info) |
1513 { | 1515 { |
1514 v8::Handle<v8::Object> holder = info.Holder(); | 1516 v8::Handle<v8::Object> holder = info.Holder(); |
| 1517 ExceptionState exceptionState(ExceptionState::SetterContext, "floatArrayAttr
ibute", "TestObject", holder, info.GetIsolate()); |
1515 TestObject* impl = V8TestObject::toImpl(holder); | 1518 TestObject* impl = V8TestObject::toImpl(holder); |
1516 TONATIVE_VOID(Vector<float>, cppValue, toImplArray<float>(v8Value, 0, info.G
etIsolate())); | 1519 TONATIVE_VOID_EXCEPTIONSTATE(Vector<float>, cppValue, toImplArray<float>(v8V
alue, 0, info.GetIsolate(), exceptionState), exceptionState); |
1517 impl->setFloatArrayAttribute(cppValue); | 1520 impl->setFloatArrayAttribute(cppValue); |
1518 } | 1521 } |
1519 | 1522 |
1520 static void floatArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1523 static void floatArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1521 { | 1524 { |
1522 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1525 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1523 TestObjectV8Internal::floatArrayAttributeAttributeSetter(v8Value, info); | 1526 TestObjectV8Internal::floatArrayAttributeAttributeSetter(v8Value, info); |
1524 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1527 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1525 } | 1528 } |
1526 | 1529 |
(...skipping 372 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1899 static void cachedArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) | 1902 static void cachedArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) |
1900 { | 1903 { |
1901 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); | 1904 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMGetter"); |
1902 TestObjectV8Internal::cachedArrayAttributeAttributeGetter(info); | 1905 TestObjectV8Internal::cachedArrayAttributeAttributeGetter(info); |
1903 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1906 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1904 } | 1907 } |
1905 | 1908 |
1906 static void cachedArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) | 1909 static void cachedArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, co
nst v8::PropertyCallbackInfo<void>& info) |
1907 { | 1910 { |
1908 v8::Handle<v8::Object> holder = info.Holder(); | 1911 v8::Handle<v8::Object> holder = info.Holder(); |
| 1912 ExceptionState exceptionState(ExceptionState::SetterContext, "cachedArrayAtt
ribute", "TestObject", holder, info.GetIsolate()); |
1909 TestObject* impl = V8TestObject::toImpl(holder); | 1913 TestObject* impl = V8TestObject::toImpl(holder); |
1910 TONATIVE_VOID(Vector<String>, cppValue, toImplArray<String>(v8Value, 0, info
.GetIsolate())); | 1914 TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, cppValue, toImplArray<String>(v
8Value, 0, info.GetIsolate(), exceptionState), exceptionState); |
1911 impl->setCachedArrayAttribute(cppValue); | 1915 impl->setCachedArrayAttribute(cppValue); |
1912 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedArrayAttribute")); // Invalidate the cached value. | 1916 V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(i
nfo.GetIsolate(), "cachedArrayAttribute")); // Invalidate the cached value. |
1913 } | 1917 } |
1914 | 1918 |
1915 static void cachedArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) | 1919 static void cachedArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) |
1916 { | 1920 { |
1917 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); | 1921 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter"); |
1918 TestObjectV8Internal::cachedArrayAttributeAttributeSetter(v8Value, info); | 1922 TestObjectV8Internal::cachedArrayAttributeAttributeSetter(v8Value, info); |
1919 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 1923 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
1920 } | 1924 } |
(...skipping 4150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6071 | 6075 |
6072 static void testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 6076 static void testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
6073 { | 6077 { |
6074 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6078 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6075 TestObjectV8Internal::testInterfaceEmptyArrayMethodMethod(info); | 6079 TestObjectV8Internal::testInterfaceEmptyArrayMethodMethod(info); |
6076 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6080 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6077 } | 6081 } |
6078 | 6082 |
6079 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) | 6083 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) |
6080 { | 6084 { |
| 6085 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodA
rrayLongArg", "TestObject", info.Holder(), info.GetIsolate()); |
6081 if (UNLIKELY(info.Length() < 1)) { | 6086 if (UNLIKELY(info.Length() < 1)) { |
6082 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayLongArg", "TestObject", 1, info.Length(), info.GetIsolate()), info
.GetIsolate()); | 6087 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6088 exceptionState.throwIfNeeded(); |
6083 return; | 6089 return; |
6084 } | 6090 } |
6085 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6091 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6086 Vector<int> arrayLongArg; | 6092 Vector<int> arrayLongArg; |
6087 { | 6093 { |
6088 v8::TryCatch block; | 6094 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arrayLongArg, toImplArray<int>(inf
o[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
6089 V8RethrowTryCatchScope rethrow(block); | |
6090 TONATIVE_VOID_INTERNAL(arrayLongArg, toImplArray<int>(info[0], 1, info.G
etIsolate())); | |
6091 } | 6095 } |
6092 impl->voidMethodArrayLongArg(arrayLongArg); | 6096 impl->voidMethodArrayLongArg(arrayLongArg); |
6093 } | 6097 } |
6094 | 6098 |
6095 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<
v8::Value>& info) | 6099 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<
v8::Value>& info) |
6096 { | 6100 { |
6097 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6101 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6098 TestObjectV8Internal::voidMethodArrayLongArgMethod(info); | 6102 TestObjectV8Internal::voidMethodArrayLongArgMethod(info); |
6099 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6103 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6100 } | 6104 } |
6101 | 6105 |
6102 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 6106 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
6103 { | 6107 { |
| 6108 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodA
rrayStringArg", "TestObject", info.Holder(), info.GetIsolate()); |
6104 if (UNLIKELY(info.Length() < 1)) { | 6109 if (UNLIKELY(info.Length() < 1)) { |
6105 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayStringArg", "TestObject", 1, info.Length(), info.GetIsolate()), in
fo.GetIsolate()); | 6110 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6111 exceptionState.throwIfNeeded(); |
6106 return; | 6112 return; |
6107 } | 6113 } |
6108 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6114 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6109 Vector<String> arrayStringArg; | 6115 Vector<String> arrayStringArg; |
6110 { | 6116 { |
6111 v8::TryCatch block; | 6117 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arrayStringArg, toImplArray<String
>(info[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
6112 V8RethrowTryCatchScope rethrow(block); | |
6113 TONATIVE_VOID_INTERNAL(arrayStringArg, toImplArray<String>(info[0], 1, i
nfo.GetIsolate())); | |
6114 } | 6118 } |
6115 impl->voidMethodArrayStringArg(arrayStringArg); | 6119 impl->voidMethodArrayStringArg(arrayStringArg); |
6116 } | 6120 } |
6117 | 6121 |
6118 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 6122 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
6119 { | 6123 { |
6120 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6124 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6121 TestObjectV8Internal::voidMethodArrayStringArgMethod(info); | 6125 TestObjectV8Internal::voidMethodArrayStringArgMethod(info); |
6122 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6126 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6123 } | 6127 } |
6124 | 6128 |
6125 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 6129 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
6126 { | 6130 { |
| 6131 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodA
rrayTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); |
6127 if (UNLIKELY(info.Length() < 1)) { | 6132 if (UNLIKELY(info.Length() < 1)) { |
6128 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodArrayTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIs
olate()), info.GetIsolate()); | 6133 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6134 exceptionState.throwIfNeeded(); |
6129 return; | 6135 return; |
6130 } | 6136 } |
6131 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6137 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6132 Vector<RefPtr<TestInterfaceEmpty> > arrayTestInterfaceEmptyArg; | 6138 Vector<RefPtr<TestInterfaceEmpty> > arrayTestInterfaceEmptyArg; |
6133 { | 6139 { |
6134 v8::TryCatch block; | 6140 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arrayTestInterfaceEmptyArg, (toRef
PtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIso
late(), exceptionState)), exceptionState); |
6135 V8RethrowTryCatchScope rethrow(block); | |
6136 TONATIVE_VOID_INTERNAL(arrayTestInterfaceEmptyArg, (toRefPtrNativeArray<
TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate()))); | |
6137 } | 6141 } |
6138 impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg); | 6142 impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg); |
6139 } | 6143 } |
6140 | 6144 |
6141 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 6145 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
6142 { | 6146 { |
6143 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6147 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6144 TestObjectV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info); | 6148 TestObjectV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info); |
6145 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6149 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6146 } | 6150 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6179 | 6183 |
6180 static void testInterfaceEmptySequenceMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 6184 static void testInterfaceEmptySequenceMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
6181 { | 6185 { |
6182 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6186 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6183 TestObjectV8Internal::testInterfaceEmptySequenceMethodMethod(info); | 6187 TestObjectV8Internal::testInterfaceEmptySequenceMethodMethod(info); |
6184 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6188 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6185 } | 6189 } |
6186 | 6190 |
6187 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 6191 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
6188 { | 6192 { |
| 6193 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
equenceLongArg", "TestObject", info.Holder(), info.GetIsolate()); |
6189 if (UNLIKELY(info.Length() < 1)) { | 6194 if (UNLIKELY(info.Length() < 1)) { |
6190 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodSequenceLongArg", "TestObject", 1, info.Length(), info.GetIsolate()), i
nfo.GetIsolate()); | 6195 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6196 exceptionState.throwIfNeeded(); |
6191 return; | 6197 return; |
6192 } | 6198 } |
6193 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6199 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6194 Vector<int> longSequenceArg; | 6200 Vector<int> longSequenceArg; |
6195 { | 6201 { |
6196 v8::TryCatch block; | 6202 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longSequenceArg, toImplArray<int>(
info[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
6197 V8RethrowTryCatchScope rethrow(block); | |
6198 TONATIVE_VOID_INTERNAL(longSequenceArg, toImplArray<int>(info[0], 1, inf
o.GetIsolate())); | |
6199 } | 6203 } |
6200 impl->voidMethodSequenceLongArg(longSequenceArg); | 6204 impl->voidMethodSequenceLongArg(longSequenceArg); |
6201 } | 6205 } |
6202 | 6206 |
6203 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 6207 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
6204 { | 6208 { |
6205 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6209 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6206 TestObjectV8Internal::voidMethodSequenceLongArgMethod(info); | 6210 TestObjectV8Internal::voidMethodSequenceLongArgMethod(info); |
6207 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6211 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6208 } | 6212 } |
6209 | 6213 |
6210 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 6214 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
6211 { | 6215 { |
| 6216 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
equenceStringArg", "TestObject", info.Holder(), info.GetIsolate()); |
6212 if (UNLIKELY(info.Length() < 1)) { | 6217 if (UNLIKELY(info.Length() < 1)) { |
6213 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodSequenceStringArg", "TestObject", 1, info.Length(), info.GetIsolate()),
info.GetIsolate()); | 6218 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6219 exceptionState.throwIfNeeded(); |
6214 return; | 6220 return; |
6215 } | 6221 } |
6216 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6222 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6217 Vector<String> stringSequenceArg; | 6223 Vector<String> stringSequenceArg; |
6218 { | 6224 { |
6219 v8::TryCatch block; | 6225 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(stringSequenceArg, toImplArray<Str
ing>(info[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
6220 V8RethrowTryCatchScope rethrow(block); | |
6221 TONATIVE_VOID_INTERNAL(stringSequenceArg, toImplArray<String>(info[0], 1
, info.GetIsolate())); | |
6222 } | 6226 } |
6223 impl->voidMethodSequenceStringArg(stringSequenceArg); | 6227 impl->voidMethodSequenceStringArg(stringSequenceArg); |
6224 } | 6228 } |
6225 | 6229 |
6226 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 6230 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
6227 { | 6231 { |
6228 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6232 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6229 TestObjectV8Internal::voidMethodSequenceStringArgMethod(info); | 6233 TestObjectV8Internal::voidMethodSequenceStringArgMethod(info); |
6230 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6234 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6231 } | 6235 } |
6232 | 6236 |
6233 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 6237 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
6234 { | 6238 { |
| 6239 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
equenceTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); |
6235 if (UNLIKELY(info.Length() < 1)) { | 6240 if (UNLIKELY(info.Length() < 1)) { |
6236 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodSequenceTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.Ge
tIsolate()), info.GetIsolate()); | 6241 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6242 exceptionState.throwIfNeeded(); |
6237 return; | 6243 return; |
6238 } | 6244 } |
6239 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6245 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6240 Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptySequenceArg; | 6246 Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptySequenceArg; |
6241 { | 6247 { |
6242 v8::TryCatch block; | 6248 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testInterfaceEmptySequenceArg, (to
RefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.Get
Isolate(), exceptionState)), exceptionState); |
6243 V8RethrowTryCatchScope rethrow(block); | |
6244 TONATIVE_VOID_INTERNAL(testInterfaceEmptySequenceArg, (toRefPtrNativeArr
ay<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate()))); | |
6245 } | 6249 } |
6246 impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg)
; | 6250 impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg)
; |
6247 } | 6251 } |
6248 | 6252 |
6249 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 6253 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
6250 { | 6254 { |
6251 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6255 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6252 TestObjectV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info); | 6256 TestObjectV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info); |
6253 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6257 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6254 } | 6258 } |
6255 | 6259 |
6256 static void voidMethodSequenceSequenceDOMStringArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 6260 static void voidMethodSequenceSequenceDOMStringArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
6257 { | 6261 { |
| 6262 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
equenceSequenceDOMStringArg", "TestObject", info.Holder(), info.GetIsolate()); |
6258 if (UNLIKELY(info.Length() < 1)) { | 6263 if (UNLIKELY(info.Length() < 1)) { |
6259 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodSequenceSequenceDOMStringArg", "TestObject", 1, info.Length(), info.Get
Isolate()), info.GetIsolate()); | 6264 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6265 exceptionState.throwIfNeeded(); |
6260 return; | 6266 return; |
6261 } | 6267 } |
6262 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6268 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6263 Vector<Vector<String> > stringSequenceSequenceArg; | 6269 Vector<Vector<String> > stringSequenceSequenceArg; |
6264 { | 6270 { |
6265 v8::TryCatch block; | 6271 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(stringSequenceSequenceArg, toImplA
rray<Vector<String>>(info[0], 1, info.GetIsolate(), exceptionState), exceptionSt
ate); |
6266 V8RethrowTryCatchScope rethrow(block); | |
6267 TONATIVE_VOID_INTERNAL(stringSequenceSequenceArg, toImplArray<Vector<Str
ing>>(info[0], 1, info.GetIsolate())); | |
6268 } | 6272 } |
6269 impl->voidMethodSequenceSequenceDOMStringArg(stringSequenceSequenceArg); | 6273 impl->voidMethodSequenceSequenceDOMStringArg(stringSequenceSequenceArg); |
6270 } | 6274 } |
6271 | 6275 |
6272 static void voidMethodSequenceSequenceDOMStringArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 6276 static void voidMethodSequenceSequenceDOMStringArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
6273 { | 6277 { |
6274 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6278 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6275 TestObjectV8Internal::voidMethodSequenceSequenceDOMStringArgMethod(info); | 6279 TestObjectV8Internal::voidMethodSequenceSequenceDOMStringArgMethod(info); |
6276 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6280 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6277 } | 6281 } |
(...skipping 311 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6589 v8::TryCatch block; | 6593 v8::TryCatch block; |
6590 V8RethrowTryCatchScope rethrow(block); | 6594 V8RethrowTryCatchScope rethrow(block); |
6591 TONATIVE_VOID_EXCEPTIONSTATE_PROMISE_INTERNAL(arg1, toInt32(info[0], exc
eptionState), exceptionState, info, ScriptState::current(info.GetIsolate())); | 6595 TONATIVE_VOID_EXCEPTIONSTATE_PROMISE_INTERNAL(arg1, toInt32(info[0], exc
eptionState), exceptionState, info, ScriptState::current(info.GetIsolate())); |
6592 if (!isUndefinedOrNull(info[1]) && !info[1]->IsObject()) { | 6596 if (!isUndefinedOrNull(info[1]) && !info[1]->IsObject()) { |
6593 exceptionState.throwTypeError("parameter 2 ('arg2') is not an object
."); | 6597 exceptionState.throwTypeError("parameter 2 ('arg2') is not an object
."); |
6594 v8SetReturnValue(info, exceptionState.reject(ScriptState::current(in
fo.GetIsolate())).v8Value()); | 6598 v8SetReturnValue(info, exceptionState.reject(ScriptState::current(in
fo.GetIsolate())).v8Value()); |
6595 return; | 6599 return; |
6596 } | 6600 } |
6597 arg2 = Dictionary(info[1], info.GetIsolate()); | 6601 arg2 = Dictionary(info[1], info.GetIsolate()); |
6598 TOSTRING_VOID_PROMISE_INTERNAL(arg3, info[2], info); | 6602 TOSTRING_VOID_PROMISE_INTERNAL(arg3, info[2], info); |
6599 TONATIVE_VOID_PROMISE_INTERNAL(variadic, toImplArguments<String>(info, 3
), info); | 6603 TONATIVE_VOID_EXCEPTIONSTATE_PROMISE_INTERNAL(variadic, toImplArguments<
String>(info, 3, exceptionState), exceptionState, info, ScriptState::current(inf
o.GetIsolate())); |
6600 } | 6604 } |
6601 v8SetReturnValue(info, impl->promiseMethod(arg1, arg2, arg3, variadic).v8Val
ue()); | 6605 v8SetReturnValue(info, impl->promiseMethod(arg1, arg2, arg3, variadic).v8Val
ue()); |
6602 } | 6606 } |
6603 | 6607 |
6604 static void promiseMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value
>& info) | 6608 static void promiseMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value
>& info) |
6605 { | 6609 { |
6606 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6610 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6607 TestObjectV8Internal::promiseMethodMethod(info); | 6611 TestObjectV8Internal::promiseMethodMethod(info); |
6608 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6612 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6609 } | 6613 } |
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6777 | 6781 |
6778 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 6782 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
6779 { | 6783 { |
6780 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6784 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6781 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info); | 6785 TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info); |
6782 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6786 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6783 } | 6787 } |
6784 | 6788 |
6785 static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 6789 static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
6786 { | 6790 { |
| 6791 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD
ictionarySequenceArg", "TestObject", info.Holder(), info.GetIsolate()); |
6787 if (UNLIKELY(info.Length() < 1)) { | 6792 if (UNLIKELY(info.Length() < 1)) { |
6788 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodDictionarySequenceArg", "TestObject", 1, info.Length(), info.GetIsolate
()), info.GetIsolate()); | 6793 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 6794 exceptionState.throwIfNeeded(); |
6789 return; | 6795 return; |
6790 } | 6796 } |
6791 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 6797 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
6792 Vector<Dictionary> dictionarySequenceArg; | 6798 Vector<Dictionary> dictionarySequenceArg; |
6793 { | 6799 { |
6794 v8::TryCatch block; | 6800 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(dictionarySequenceArg, toImplArray
<Dictionary>(info[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
6795 V8RethrowTryCatchScope rethrow(block); | |
6796 TONATIVE_VOID_INTERNAL(dictionarySequenceArg, toImplArray<Dictionary>(in
fo[0], 1, info.GetIsolate())); | |
6797 } | 6801 } |
6798 impl->voidMethodDictionarySequenceArg(dictionarySequenceArg); | 6802 impl->voidMethodDictionarySequenceArg(dictionarySequenceArg); |
6799 } | 6803 } |
6800 | 6804 |
6801 static void voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 6805 static void voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
6802 { | 6806 { |
6803 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 6807 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
6804 TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info); | 6808 TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info); |
6805 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 6809 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
6806 } | 6810 } |
(...skipping 553 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7360 | 7364 |
7361 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) | 7365 static void voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::Fu
nctionCallbackInfo<v8::Value>& info) |
7362 { | 7366 { |
7363 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7367 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7364 TestObjectV8Internal::voidMethodDefaultNullableTestInterfaceArgMethod(info); | 7368 TestObjectV8Internal::voidMethodDefaultNullableTestInterfaceArgMethod(info); |
7365 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7369 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7366 } | 7370 } |
7367 | 7371 |
7368 static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 7372 static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
7369 { | 7373 { |
| 7374 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodV
ariadicStringArg", "TestObject", info.Holder(), info.GetIsolate()); |
7370 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7375 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7371 Vector<String> variadicStringArgs; | 7376 Vector<String> variadicStringArgs; |
7372 { | 7377 { |
7373 v8::TryCatch block; | 7378 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(variadicStringArgs, toImplArgument
s<String>(info, 0, exceptionState), exceptionState); |
7374 V8RethrowTryCatchScope rethrow(block); | |
7375 TONATIVE_VOID_INTERNAL(variadicStringArgs, toImplArguments<String>(info,
0)); | |
7376 } | 7379 } |
7377 impl->voidMethodVariadicStringArg(variadicStringArgs); | 7380 impl->voidMethodVariadicStringArg(variadicStringArgs); |
7378 } | 7381 } |
7379 | 7382 |
7380 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 7383 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
7381 { | 7384 { |
7382 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7385 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7383 TestObjectV8Internal::voidMethodVariadicStringArgMethod(info); | 7386 TestObjectV8Internal::voidMethodVariadicStringArgMethod(info); |
7384 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7387 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7385 } | 7388 } |
7386 | 7389 |
7387 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 7390 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
7388 { | 7391 { |
| 7392 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
tringArgVariadicStringArg", "TestObject", info.Holder(), info.GetIsolate()); |
7389 if (UNLIKELY(info.Length() < 1)) { | 7393 if (UNLIKELY(info.Length() < 1)) { |
7390 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodStringArgVariadicStringArg", "TestObject", 1, info.Length(), info.GetIs
olate()), info.GetIsolate()); | 7394 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 7395 exceptionState.throwIfNeeded(); |
7391 return; | 7396 return; |
7392 } | 7397 } |
7393 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7398 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7394 V8StringResource<> stringArg; | 7399 V8StringResource<> stringArg; |
7395 Vector<String> variadicStringArgs; | 7400 Vector<String> variadicStringArgs; |
7396 { | 7401 { |
7397 v8::TryCatch block; | |
7398 V8RethrowTryCatchScope rethrow(block); | |
7399 TOSTRING_VOID_INTERNAL(stringArg, info[0]); | 7402 TOSTRING_VOID_INTERNAL(stringArg, info[0]); |
7400 TONATIVE_VOID_INTERNAL(variadicStringArgs, toImplArguments<String>(info,
1)); | 7403 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(variadicStringArgs, toImplArgument
s<String>(info, 1, exceptionState), exceptionState); |
7401 } | 7404 } |
7402 impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs); | 7405 impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs); |
7403 } | 7406 } |
7404 | 7407 |
7405 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 7408 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
7406 { | 7409 { |
7407 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7410 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7408 TestObjectV8Internal::voidMethodStringArgVariadicStringArgMethod(info); | 7411 TestObjectV8Internal::voidMethodStringArgVariadicStringArgMethod(info); |
7409 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7412 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7410 } | 7413 } |
7411 | 7414 |
7412 static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 7415 static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
7413 { | 7416 { |
| 7417 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodV
ariadicTestInterfaceEmptyArg", "TestObject", info.Holder(), info.GetIsolate()); |
7414 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7418 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7415 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; | 7419 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; |
7416 { | 7420 { |
7417 for (int i = 0; i < info.Length(); ++i) { | 7421 for (int i = 0; i < info.Length(); ++i) { |
7418 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ | 7422 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ |
7419 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodVariadicTestInterfaceEmptyArg", "TestObject", "parameter 1 is not
of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 7423 exceptionState.throwTypeError("parameter 1 is not of type 'TestI
nterfaceEmpty'."); |
| 7424 exceptionState.throwIfNeeded(); |
7420 return; | 7425 return; |
7421 } | 7426 } |
7422 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); | 7427 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); |
7423 } | 7428 } |
7424 } | 7429 } |
7425 impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs
); | 7430 impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs
); |
7426 } | 7431 } |
7427 | 7432 |
7428 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 7433 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
7429 { | 7434 { |
7430 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7435 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7431 TestObjectV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info); | 7436 TestObjectV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info); |
7432 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7437 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7433 } | 7438 } |
7434 | 7439 |
7435 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 7440 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
7436 { | 7441 { |
| 7442 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", info.Holder(),
info.GetIsolate()); |
7437 if (UNLIKELY(info.Length() < 1)) { | 7443 if (UNLIKELY(info.Length() < 1)) { |
7438 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject", 1, i
nfo.Length(), info.GetIsolate()), info.GetIsolate()); | 7444 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 7445 exceptionState.throwIfNeeded(); |
7439 return; | 7446 return; |
7440 } | 7447 } |
7441 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7448 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7442 TestInterfaceEmpty* testInterfaceEmptyArg; | 7449 TestInterfaceEmpty* testInterfaceEmptyArg; |
7443 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; | 7450 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; |
7444 { | 7451 { |
7445 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); | 7452 testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.G
etIsolate(), info[0]); |
7446 for (int i = 1; i < info.Length(); ++i) { | 7453 for (int i = 1; i < info.Length(); ++i) { |
7447 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ | 7454 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ |
7448 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObject"
, "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 7455 exceptionState.throwTypeError("parameter 2 is not of type 'TestI
nterfaceEmpty'."); |
| 7456 exceptionState.throwIfNeeded(); |
7449 return; | 7457 return; |
7450 } | 7458 } |
7451 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); | 7459 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toImpl(v
8::Handle<v8::Object>::Cast(info[i]))); |
7452 } | 7460 } |
7453 } | 7461 } |
7454 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); | 7462 impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInter
faceEmptyArg, variadicTestInterfaceEmptyArgs); |
7455 } | 7463 } |
7456 | 7464 |
7457 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) | 7465 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) |
7458 { | 7466 { |
7459 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7467 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7460 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEm
ptyArgMethod(info); | 7468 TestObjectV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEm
ptyArgMethod(info); |
7461 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7469 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7462 } | 7470 } |
7463 | 7471 |
7464 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::F
unctionCallbackInfo<v8::Value>& info) | 7472 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::F
unctionCallbackInfo<v8::Value>& info) |
7465 { | 7473 { |
| 7474 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodV
ariadicTestInterfaceGarbageCollectedArg", "TestObject", info.Holder(), info.GetI
solate()); |
7466 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7475 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7467 HeapVector<Member<TestInterfaceGarbageCollected> > variadicTestInterfaceGarb
ageCollectedArg; | 7476 HeapVector<Member<TestInterfaceGarbageCollected> > variadicTestInterfaceGarb
ageCollectedArg; |
7468 { | 7477 { |
7469 for (int i = 0; i < info.Length(); ++i) { | 7478 for (int i = 0; i < info.Length(); ++i) { |
7470 if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetI
solate())) { | 7479 if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetI
solate())) { |
7471 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodVariadicTestInterfaceGarbageCollectedArg", "TestObject", "paramet
er 1 is not of type 'TestInterfaceGarbageCollected'."), info.GetIsolate()); | 7480 exceptionState.throwTypeError("parameter 1 is not of type 'TestI
nterfaceGarbageCollected'."); |
| 7481 exceptionState.throwIfNeeded(); |
7472 return; | 7482 return; |
7473 } | 7483 } |
7474 variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarba
geCollected::toImpl(v8::Handle<v8::Object>::Cast(info[i]))); | 7484 variadicTestInterfaceGarbageCollectedArg.append(V8TestInterfaceGarba
geCollected::toImpl(v8::Handle<v8::Object>::Cast(info[i]))); |
7475 } | 7485 } |
7476 } | 7486 } |
7477 impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfa
ceGarbageCollectedArg); | 7487 impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfa
ceGarbageCollectedArg); |
7478 } | 7488 } |
7479 | 7489 |
7480 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback(con
st v8::FunctionCallbackInfo<v8::Value>& info) | 7490 static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback(con
st v8::FunctionCallbackInfo<v8::Value>& info) |
7481 { | 7491 { |
7482 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 7492 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
7483 TestObjectV8Internal::voidMethodVariadicTestInterfaceGarbageCollectedArgMeth
od(info); | 7493 TestObjectV8Internal::voidMethodVariadicTestInterfaceGarbageCollectedArgMeth
od(info); |
7484 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 7494 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
7485 } | 7495 } |
7486 | 7496 |
7487 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) | 7497 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) |
7488 { | 7498 { |
| 7499 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodV
ariadicTestInterfaceWillBeGarbageCollectedArg", "TestObject", info.Holder(), inf
o.GetIsolate()); |
7489 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7500 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7490 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > v
ariadicTestInterfaceWillBeGarbageCollectedArg; | 7501 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > v
ariadicTestInterfaceWillBeGarbageCollectedArg; |
7491 { | 7502 { |
7492 for (int i = 0; i < info.Length(); ++i) { | 7503 for (int i = 0; i < info.Length(); ++i) { |
7493 if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], inf
o.GetIsolate())) { | 7504 if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], inf
o.GetIsolate())) { |
7494 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg", "TestObject", "p
arameter 1 is not of type 'TestInterfaceWillBeGarbageCollected'."), info.GetIsol
ate()); | 7505 exceptionState.throwTypeError("parameter 1 is not of type 'TestI
nterfaceWillBeGarbageCollected'."); |
| 7506 exceptionState.throwIfNeeded(); |
7495 return; | 7507 return; |
7496 } | 7508 } |
7497 variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfac
eWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(info[i]))); | 7509 variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfac
eWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(info[i]))); |
7498 } | 7510 } |
7499 } | 7511 } |
7500 impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestI
nterfaceWillBeGarbageCollectedArg); | 7512 impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestI
nterfaceWillBeGarbageCollectedArg); |
7501 } | 7513 } |
7502 | 7514 |
7503 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallba
ck(const v8::FunctionCallbackInfo<v8::Value>& info) | 7515 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallba
ck(const v8::FunctionCallbackInfo<v8::Value>& info) |
7504 { | 7516 { |
(...skipping 183 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7688 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7700 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7689 int longArg; | 7701 int longArg; |
7690 { | 7702 { |
7691 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); | 7703 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptio
nState), exceptionState); |
7692 } | 7704 } |
7693 impl->overloadedMethodD(longArg); | 7705 impl->overloadedMethodD(longArg); |
7694 } | 7706 } |
7695 | 7707 |
7696 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 7708 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
7697 { | 7709 { |
| 7710 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodD", "TestObject", info.Holder(), info.GetIsolate()); |
7698 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 7711 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
7699 Vector<int> longArrayArg; | 7712 Vector<int> longArrayArg; |
7700 { | 7713 { |
7701 v8::TryCatch block; | 7714 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArrayArg, toImplArray<int>(inf
o[0], 1, info.GetIsolate(), exceptionState), exceptionState); |
7702 V8RethrowTryCatchScope rethrow(block); | |
7703 TONATIVE_VOID_INTERNAL(longArrayArg, toImplArray<int>(info[0], 1, info.G
etIsolate())); | |
7704 } | 7715 } |
7705 impl->overloadedMethodD(longArrayArg); | 7716 impl->overloadedMethodD(longArrayArg); |
7706 } | 7717 } |
7707 | 7718 |
7708 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 7719 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
7709 { | 7720 { |
7710 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodD", "TestObject", info.Holder(), info.GetIsolate()); | 7721 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodD", "TestObject", info.Holder(), info.GetIsolate()); |
7711 switch (std::min(1, info.Length())) { | 7722 switch (std::min(1, info.Length())) { |
7712 case 1: | 7723 case 1: |
7713 if (info[0]->IsArray()) { | 7724 if (info[0]->IsArray()) { |
(...skipping 720 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8434 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 8445 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8435 impl->activityLoggingAccessForAllWorldsMethod(); | 8446 impl->activityLoggingAccessForAllWorldsMethod(); |
8436 } | 8447 } |
8437 | 8448 |
8438 static void activityLoggingAccessForAllWorldsMethodMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 8449 static void activityLoggingAccessForAllWorldsMethodMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
8439 { | 8450 { |
8440 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 8451 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
8441 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); | 8452 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); |
8442 V8PerContextData* contextData = scriptState->perContextData(); | 8453 V8PerContextData* contextData = scriptState->perContextData(); |
8443 if (contextData && contextData->activityLogger()) { | 8454 if (contextData && contextData->activityLogger()) { |
8444 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0); | 8455 ExceptionState exceptionState(ExceptionState::ExecutionContext, "activit
yLoggingAccessForAllWorldsMethod", "TestObject", info.Holder(), info.GetIsolate(
)); |
| 8456 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0, exceptionState); |
8445 contextData->activityLogger()->logMethod("TestObject.activityLoggingAcce
ssForAllWorldsMethod", info.Length(), loggerArgs.data()); | 8457 contextData->activityLogger()->logMethod("TestObject.activityLoggingAcce
ssForAllWorldsMethod", info.Length(), loggerArgs.data()); |
8446 } | 8458 } |
8447 TestObjectV8Internal::activityLoggingAccessForAllWorldsMethodMethod(info); | 8459 TestObjectV8Internal::activityLoggingAccessForAllWorldsMethodMethod(info); |
8448 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 8460 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
8449 } | 8461 } |
8450 | 8462 |
8451 static void callWithExecutionContextVoidMethodMethod(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 8463 static void callWithExecutionContextVoidMethodMethod(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
8452 { | 8464 { |
8453 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 8465 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
8454 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); | 8466 ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate
()); |
(...skipping 708 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9163 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9175 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9164 impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod(); | 9176 impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod(); |
9165 } | 9177 } |
9166 | 9178 |
9167 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) | 9179 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) |
9168 { | 9180 { |
9169 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9181 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9170 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); | 9182 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); |
9171 V8PerContextData* contextData = scriptState->perContextData(); | 9183 V8PerContextData* contextData = scriptState->perContextData(); |
9172 if (contextData && contextData->activityLogger()) { | 9184 if (contextData && contextData->activityLogger()) { |
9173 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0); | 9185 ExceptionState exceptionState(ExceptionState::ExecutionContext, "activit
yLoggingForAllWorldsPerWorldBindingsVoidMethod", "TestObject", info.Holder(), in
fo.GetIsolate()); |
| 9186 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0, exceptionState); |
9174 contextData->activityLogger()->logMethod("TestObject.activityLoggingForA
llWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); | 9187 contextData->activityLogger()->logMethod("TestObject.activityLoggingForA
llWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); |
9175 } | 9188 } |
9176 TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodM
ethod(info); | 9189 TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodM
ethod(info); |
9177 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9190 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9178 } | 9191 } |
9179 | 9192 |
9180 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWo
rld(const v8::FunctionCallbackInfo<v8::Value>& info) | 9193 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWo
rld(const v8::FunctionCallbackInfo<v8::Value>& info) |
9181 { | 9194 { |
9182 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9195 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9183 impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod(); | 9196 impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod(); |
9184 } | 9197 } |
9185 | 9198 |
9186 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackF
orMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) | 9199 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackF
orMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) |
9187 { | 9200 { |
9188 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9201 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9189 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); | 9202 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); |
9190 V8PerContextData* contextData = scriptState->perContextData(); | 9203 V8PerContextData* contextData = scriptState->perContextData(); |
9191 if (contextData && contextData->activityLogger()) { | 9204 if (contextData && contextData->activityLogger()) { |
9192 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0); | 9205 ExceptionState exceptionState(ExceptionState::ExecutionContext, "activit
yLoggingForAllWorldsPerWorldBindingsVoidMethod", "TestObject", info.Holder(), in
fo.GetIsolate()); |
| 9206 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0, exceptionState); |
9193 contextData->activityLogger()->logMethod("TestObject.activityLoggingForA
llWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); | 9207 contextData->activityLogger()->logMethod("TestObject.activityLoggingForA
llWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); |
9194 } | 9208 } |
9195 TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodM
ethodForMainWorld(info); | 9209 TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodM
ethodForMainWorld(info); |
9196 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9210 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9197 } | 9211 } |
9198 | 9212 |
9199 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(con
st v8::FunctionCallbackInfo<v8::Value>& info) | 9213 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(con
st v8::FunctionCallbackInfo<v8::Value>& info) |
9200 { | 9214 { |
9201 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9215 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9202 impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod(); | 9216 impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod(); |
9203 } | 9217 } |
9204 | 9218 |
9205 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCall
back(const v8::FunctionCallbackInfo<v8::Value>& info) | 9219 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCall
back(const v8::FunctionCallbackInfo<v8::Value>& info) |
9206 { | 9220 { |
9207 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9221 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9208 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); | 9222 ScriptState* scriptState = ScriptState::from(info.GetIsolate()->GetCurrentCo
ntext()); |
9209 V8PerContextData* contextData = scriptState->perContextData(); | 9223 V8PerContextData* contextData = scriptState->perContextData(); |
9210 if (contextData && contextData->activityLogger()) { | 9224 if (contextData && contextData->activityLogger()) { |
9211 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0); | 9225 ExceptionState exceptionState(ExceptionState::ExecutionContext, "activit
yLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", "TestObject", info.Holder(
), info.GetIsolate()); |
| 9226 Vector<v8::Handle<v8::Value> > loggerArgs = toImplArguments<v8::Handle<v
8::Value> >(info, 0, exceptionState); |
9212 contextData->activityLogger()->logMethod("TestObject.activityLoggingForI
solatedWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); | 9227 contextData->activityLogger()->logMethod("TestObject.activityLoggingForI
solatedWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data()); |
9213 } | 9228 } |
9214 TestObjectV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMe
thodMethod(info); | 9229 TestObjectV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMe
thodMethod(info); |
9215 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9230 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9216 } | 9231 } |
9217 | 9232 |
9218 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForM
ainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) | 9233 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForM
ainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) |
9219 { | 9234 { |
9220 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9235 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9221 impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod(); | 9236 impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod(); |
(...skipping 446 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9668 | 9683 |
9669 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9684 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
9670 { | 9685 { |
9671 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9686 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9672 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); | 9687 TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMe
thod(info); |
9673 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9688 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9674 } | 9689 } |
9675 | 9690 |
9676 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 9691 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
9677 { | 9692 { |
| 9693 ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckin
gInterfaceVoidMethodTestInterfaceEmptyVariadicArg", "TestObject", info.Holder(),
info.GetIsolate()); |
9678 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9694 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9679 Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptyArg; | 9695 Vector<RefPtr<TestInterfaceEmpty> > testInterfaceEmptyArg; |
9680 { | 9696 { |
9681 for (int i = 0; i < info.Length(); ++i) { | 9697 for (int i = 0; i < info.Length(); ++i) { |
9682 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ | 9698 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate()))
{ |
9683 V8ThrowException::throwTypeError(ExceptionMessages::failedToExec
ute("typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArg", "TestObject"
, "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 9699 exceptionState.throwTypeError("parameter 1 is not of type 'TestI
nterfaceEmpty'."); |
| 9700 exceptionState.throwIfNeeded(); |
9684 return; | 9701 return; |
9685 } | 9702 } |
9686 testInterfaceEmptyArg.append(V8TestInterfaceEmpty::toImpl(v8::Handle
<v8::Object>::Cast(info[i]))); | 9703 testInterfaceEmptyArg.append(V8TestInterfaceEmpty::toImpl(v8::Handle
<v8::Object>::Cast(info[i]))); |
9687 } | 9704 } |
9688 } | 9705 } |
9689 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArg(testInter
faceEmptyArg); | 9706 impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArg(testInter
faceEmptyArg); |
9690 } | 9707 } |
9691 | 9708 |
9692 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) | 9709 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) |
9693 { | 9710 { |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9739 | 9756 |
9740 static void unforgeableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 9757 static void unforgeableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
9741 { | 9758 { |
9742 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9759 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9743 TestObjectV8Internal::unforgeableVoidMethodMethod(info); | 9760 TestObjectV8Internal::unforgeableVoidMethodMethod(info); |
9744 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9761 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9745 } | 9762 } |
9746 | 9763 |
9747 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::F
unctionCallbackInfo<v8::Value>& info) | 9764 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::F
unctionCallbackInfo<v8::Value>& info) |
9748 { | 9765 { |
| 9766 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceGarbageCollectedSequenceArg", "TestObject", info.Holder(), info.GetI
solate()); |
9749 if (UNLIKELY(info.Length() < 1)) { | 9767 if (UNLIKELY(info.Length() < 1)) { |
9750 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceGarbageCollectedSequenceArg", "TestObject", 1, info.Length
(), info.GetIsolate()), info.GetIsolate()); | 9768 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 9769 exceptionState.throwIfNeeded(); |
9751 return; | 9770 return; |
9752 } | 9771 } |
9753 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9772 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9754 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle
ctedSequenceArg; | 9773 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle
ctedSequenceArg; |
9755 { | 9774 { |
9756 v8::TryCatch block; | 9775 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testInterfaceGarbageCollectedSeque
nceArg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarba
geCollected>(info[0], 1, info.GetIsolate(), exceptionState)), exceptionState); |
9757 V8RethrowTryCatchScope rethrow(block); | |
9758 TONATIVE_VOID_INTERNAL(testInterfaceGarbageCollectedSequenceArg, (toMemb
erNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(in
fo[0], 1, info.GetIsolate()))); | |
9759 } | 9776 } |
9760 impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbag
eCollectedSequenceArg); | 9777 impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbag
eCollectedSequenceArg); |
9761 } | 9778 } |
9762 | 9779 |
9763 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback(con
st v8::FunctionCallbackInfo<v8::Value>& info) | 9780 static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback(con
st v8::FunctionCallbackInfo<v8::Value>& info) |
9764 { | 9781 { |
9765 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9782 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9766 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMeth
od(info); | 9783 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMeth
od(info); |
9767 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9784 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9768 } | 9785 } |
9769 | 9786 |
9770 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 9787 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
9771 { | 9788 { |
| 9789 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceGarbageCollectedArrayArg", "TestObject", info.Holder(), info.GetIsol
ate()); |
9772 if (UNLIKELY(info.Length() < 1)) { | 9790 if (UNLIKELY(info.Length() < 1)) { |
9773 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceGarbageCollectedArrayArg", "TestObject", 1, info.Length(),
info.GetIsolate()), info.GetIsolate()); | 9791 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 9792 exceptionState.throwIfNeeded(); |
9774 return; | 9793 return; |
9775 } | 9794 } |
9776 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9795 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9777 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle
ctedArrayArg; | 9796 HeapVector<Member<TestInterfaceGarbageCollected> > testInterfaceGarbageColle
ctedArrayArg; |
9778 { | 9797 { |
9779 v8::TryCatch block; | 9798 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testInterfaceGarbageCollectedArray
Arg, (toMemberNativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageC
ollected>(info[0], 1, info.GetIsolate(), exceptionState)), exceptionState); |
9780 V8RethrowTryCatchScope rethrow(block); | |
9781 TONATIVE_VOID_INTERNAL(testInterfaceGarbageCollectedArrayArg, (toMemberN
ativeArray<TestInterfaceGarbageCollected, V8TestInterfaceGarbageCollected>(info[
0], 1, info.GetIsolate()))); | |
9782 } | 9799 } |
9783 impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCo
llectedArrayArg); | 9800 impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCo
llectedArrayArg); |
9784 } | 9801 } |
9785 | 9802 |
9786 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9803 static void voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
9787 { | 9804 { |
9788 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9805 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9789 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethod(
info); | 9806 TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethod(
info); |
9790 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9807 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9791 } | 9808 } |
9792 | 9809 |
9793 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) | 9810 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const
v8::FunctionCallbackInfo<v8::Value>& info) |
9794 { | 9811 { |
| 9812 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceWillBeGarbageCollectedSequenceArg", "TestObject", info.Holder(), inf
o.GetIsolate()); |
9795 if (UNLIKELY(info.Length() < 1)) { | 9813 if (UNLIKELY(info.Length() < 1)) { |
9796 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceWillBeGarbageCollectedSequenceArg", "TestObject", 1, info.
Length(), info.GetIsolate()), info.GetIsolate()); | 9814 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 9815 exceptionState.throwIfNeeded(); |
9797 return; | 9816 return; |
9798 } | 9817 } |
9799 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9818 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9800 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t
estInterfaceWillBeGarbageCollectedSequenceArg; | 9819 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t
estInterfaceWillBeGarbageCollectedSequenceArg; |
9801 { | 9820 { |
9802 v8::TryCatch block; | 9821 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testInterfaceWillBeGarbageCollecte
dSequenceArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollect
ed, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate(), except
ionState)), exceptionState); |
9803 V8RethrowTryCatchScope rethrow(block); | |
9804 TONATIVE_VOID_INTERNAL(testInterfaceWillBeGarbageCollectedSequenceArg, (
toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInter
faceWillBeGarbageCollected>(info[0], 1, info.GetIsolate()))); | |
9805 } | 9822 } |
9806 impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterface
WillBeGarbageCollectedSequenceArg); | 9823 impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterface
WillBeGarbageCollectedSequenceArg); |
9807 } | 9824 } |
9808 | 9825 |
9809 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallba
ck(const v8::FunctionCallbackInfo<v8::Value>& info) | 9826 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallba
ck(const v8::FunctionCallbackInfo<v8::Value>& info) |
9810 { | 9827 { |
9811 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9828 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9812 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceA
rgMethod(info); | 9829 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceA
rgMethod(info); |
9813 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9830 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9814 } | 9831 } |
9815 | 9832 |
9816 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8
::FunctionCallbackInfo<v8::Value>& info) | 9833 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8
::FunctionCallbackInfo<v8::Value>& info) |
9817 { | 9834 { |
| 9835 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceWillBeGarbageCollectedArrayArg", "TestObject", info.Holder(), info.G
etIsolate()); |
9818 if (UNLIKELY(info.Length() < 1)) { | 9836 if (UNLIKELY(info.Length() < 1)) { |
9819 V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("v
oidMethodTestInterfaceWillBeGarbageCollectedArrayArg", "TestObject", 1, info.Len
gth(), info.GetIsolate()), info.GetIsolate()); | 9837 setMinimumArityTypeError(exceptionState, 1, info.Length()); |
| 9838 exceptionState.throwIfNeeded(); |
9820 return; | 9839 return; |
9821 } | 9840 } |
9822 TestObject* impl = V8TestObject::toImpl(info.Holder()); | 9841 TestObject* impl = V8TestObject::toImpl(info.Holder()); |
9823 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t
estInterfaceWillBeGarbageCollectedArrayArg; | 9842 WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > t
estInterfaceWillBeGarbageCollectedArrayArg; |
9824 { | 9843 { |
9825 v8::TryCatch block; | 9844 TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testInterfaceWillBeGarbageCollecte
dArrayArg, (toRefPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected,
V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate(), exception
State)), exceptionState); |
9826 V8RethrowTryCatchScope rethrow(block); | |
9827 TONATIVE_VOID_INTERNAL(testInterfaceWillBeGarbageCollectedArrayArg, (toR
efPtrWillBeMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfac
eWillBeGarbageCollected>(info[0], 1, info.GetIsolate()))); | |
9828 } | 9845 } |
9829 impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWil
lBeGarbageCollectedArrayArg); | 9846 impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWil
lBeGarbageCollectedArrayArg); |
9830 } | 9847 } |
9831 | 9848 |
9832 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) | 9849 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) |
9833 { | 9850 { |
9834 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); | 9851 TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod"); |
9835 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgM
ethod(info); | 9852 TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgM
ethod(info); |
9836 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); | 9853 TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution"); |
9837 } | 9854 } |
(...skipping 1210 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11048 return false; | 11065 return false; |
11049 | 11066 |
11050 ScriptState::Scope scope(scriptState); | 11067 ScriptState::Scope scope(scriptState); |
11051 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); | 11068 v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Glob
al(), scriptState->isolate()); |
11052 | 11069 |
11053 ExceptionState exceptionState(ExceptionState::SetterContext, "enumForPrivate
Script", "TestObject", scriptState->context()->Global(), scriptState->isolate())
; | 11070 ExceptionState exceptionState(ExceptionState::SetterContext, "enumForPrivate
Script", "TestObject", scriptState->context()->Global(), scriptState->isolate())
; |
11054 return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateIn
UserScript, "TestObject", "enumForPrivateScript", holder, v8String(scriptState->
isolate(), cppValue)); | 11071 return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateIn
UserScript, "TestObject", "enumForPrivateScript", holder, v8String(scriptState->
isolate(), cppValue)); |
11055 } | 11072 } |
11056 | 11073 |
11057 } // namespace blink | 11074 } // namespace blink |
OLD | NEW |