OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2013 Google Inc. All rights reserved. | 2 * Copyright (C) 2013 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 3323 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3334 | 3334 |
3335 static void unsignedShortMethodMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 3335 static void unsignedShortMethodMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
3336 { | 3336 { |
3337 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3337 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3338 TestObjectPythonV8Internal::unsignedShortMethodMethod(info); | 3338 TestObjectPythonV8Internal::unsignedShortMethodMethod(info); |
3339 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3339 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3340 } | 3340 } |
3341 | 3341 |
3342 static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3342 static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3343 { | 3343 { |
3344 if (UNLIKELY(info.Length() < 1)) { | 3344 if (info.Length() < 1) { |
3345 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDateArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3345 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDateArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
3346 return; | 3346 return; |
3347 } | 3347 } |
3348 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3348 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3349 V8TRYCATCH_VOID(double, dateArg, toWebCoreDate(info[0])); | 3349 V8TRYCATCH_VOID(double, dateArg, toWebCoreDate(info[0])); |
3350 imp->voidMethodDateArg(dateArg); | 3350 imp->voidMethodDateArg(dateArg); |
3351 } | 3351 } |
3352 | 3352 |
3353 static void voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3353 static void voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3354 { | 3354 { |
3355 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3355 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3356 TestObjectPythonV8Internal::voidMethodDateArgMethod(info); | 3356 TestObjectPythonV8Internal::voidMethodDateArgMethod(info); |
3357 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3357 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3358 } | 3358 } |
3359 | 3359 |
3360 static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3360 static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3361 { | 3361 { |
3362 if (UNLIKELY(info.Length() < 1)) { | 3362 if (info.Length() < 1) { |
3363 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), i
nfo.GetIsolate()); | 3363 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), i
nfo.GetIsolate()); |
3364 return; | 3364 return; |
3365 } | 3365 } |
3366 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3366 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3367 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; | 3367 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; |
3368 imp->voidMethodStringArg(stringArg); | 3368 imp->voidMethodStringArg(stringArg); |
3369 } | 3369 } |
3370 | 3370 |
3371 static void voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 3371 static void voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
3372 { | 3372 { |
3373 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3373 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3374 TestObjectPythonV8Internal::voidMethodStringArgMethod(info); | 3374 TestObjectPythonV8Internal::voidMethodStringArgMethod(info); |
3375 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3375 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3376 } | 3376 } |
3377 | 3377 |
3378 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 3378 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
3379 { | 3379 { |
3380 if (UNLIKELY(info.Length() < 1)) { | 3380 if (info.Length() < 1) { |
3381 throwTypeError(ExceptionMessages::failedToExecute("voidMethodBooleanArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 3381 throwTypeError(ExceptionMessages::failedToExecute("voidMethodBooleanArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
3382 return; | 3382 return; |
3383 } | 3383 } |
3384 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3384 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3385 V8TRYCATCH_VOID(bool, booleanArg, info[0]->BooleanValue()); | 3385 V8TRYCATCH_VOID(bool, booleanArg, info[0]->BooleanValue()); |
3386 imp->voidMethodBooleanArg(booleanArg); | 3386 imp->voidMethodBooleanArg(booleanArg); |
3387 } | 3387 } |
3388 | 3388 |
3389 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 3389 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
3390 { | 3390 { |
3391 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3391 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3392 TestObjectPythonV8Internal::voidMethodBooleanArgMethod(info); | 3392 TestObjectPythonV8Internal::voidMethodBooleanArgMethod(info); |
3393 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3393 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3394 } | 3394 } |
3395 | 3395 |
3396 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3396 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3397 { | 3397 { |
3398 if (UNLIKELY(info.Length() < 1)) { | 3398 if (info.Length() < 1) { |
3399 throwTypeError(ExceptionMessages::failedToExecute("voidMethodByteArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3399 throwTypeError(ExceptionMessages::failedToExecute("voidMethodByteArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
3400 return; | 3400 return; |
3401 } | 3401 } |
3402 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3402 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3403 V8TRYCATCH_VOID(int, byteArg, toInt8(info[0])); | 3403 V8TRYCATCH_VOID(int, byteArg, toInt8(info[0])); |
3404 imp->voidMethodByteArg(byteArg); | 3404 imp->voidMethodByteArg(byteArg); |
3405 } | 3405 } |
3406 | 3406 |
3407 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3407 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3408 { | 3408 { |
3409 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3409 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3410 TestObjectPythonV8Internal::voidMethodByteArgMethod(info); | 3410 TestObjectPythonV8Internal::voidMethodByteArgMethod(info); |
3411 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3411 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3412 } | 3412 } |
3413 | 3413 |
3414 static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3414 static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3415 { | 3415 { |
3416 if (UNLIKELY(info.Length() < 1)) { | 3416 if (info.Length() < 1) { |
3417 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDoubleArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), i
nfo.GetIsolate()); | 3417 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDoubleArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), i
nfo.GetIsolate()); |
3418 return; | 3418 return; |
3419 } | 3419 } |
3420 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3420 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3421 V8TRYCATCH_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue(
))); | 3421 V8TRYCATCH_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue(
))); |
3422 imp->voidMethodDoubleArg(doubleArg); | 3422 imp->voidMethodDoubleArg(doubleArg); |
3423 } | 3423 } |
3424 | 3424 |
3425 static void voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 3425 static void voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
3426 { | 3426 { |
3427 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3427 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3428 TestObjectPythonV8Internal::voidMethodDoubleArgMethod(info); | 3428 TestObjectPythonV8Internal::voidMethodDoubleArgMethod(info); |
3429 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3429 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3430 } | 3430 } |
3431 | 3431 |
3432 static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3432 static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3433 { | 3433 { |
3434 if (UNLIKELY(info.Length() < 1)) { | 3434 if (info.Length() < 1) { |
3435 throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloatArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); | 3435 throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloatArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); |
3436 return; | 3436 return; |
3437 } | 3437 } |
3438 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3438 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3439 V8TRYCATCH_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue()))
; | 3439 V8TRYCATCH_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue()))
; |
3440 imp->voidMethodFloatArg(floatArg); | 3440 imp->voidMethodFloatArg(floatArg); |
3441 } | 3441 } |
3442 | 3442 |
3443 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3443 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3444 { | 3444 { |
3445 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3445 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3446 TestObjectPythonV8Internal::voidMethodFloatArgMethod(info); | 3446 TestObjectPythonV8Internal::voidMethodFloatArgMethod(info); |
3447 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3447 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3448 } | 3448 } |
3449 | 3449 |
3450 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3450 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3451 { | 3451 { |
3452 if (UNLIKELY(info.Length() < 1)) { | 3452 if (info.Length() < 1) { |
3453 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3453 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
3454 return; | 3454 return; |
3455 } | 3455 } |
3456 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3456 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3457 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 3457 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
3458 imp->voidMethodLongArg(longArg); | 3458 imp->voidMethodLongArg(longArg); |
3459 } | 3459 } |
3460 | 3460 |
3461 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3461 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3462 { | 3462 { |
3463 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3463 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3464 TestObjectPythonV8Internal::voidMethodLongArgMethod(info); | 3464 TestObjectPythonV8Internal::voidMethodLongArgMethod(info); |
3465 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3465 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3466 } | 3466 } |
3467 | 3467 |
3468 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 3468 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
3469 { | 3469 { |
3470 if (UNLIKELY(info.Length() < 1)) { | 3470 if (info.Length() < 1) { |
3471 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongLongArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 3471 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongLongArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
3472 return; | 3472 return; |
3473 } | 3473 } |
3474 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3474 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3475 V8TRYCATCH_VOID(long long, longLongArg, toInt64(info[0])); | 3475 V8TRYCATCH_VOID(long long, longLongArg, toInt64(info[0])); |
3476 imp->voidMethodLongLongArg(longLongArg); | 3476 imp->voidMethodLongLongArg(longLongArg); |
3477 } | 3477 } |
3478 | 3478 |
3479 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 3479 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
3480 { | 3480 { |
3481 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3481 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3482 TestObjectPythonV8Internal::voidMethodLongLongArgMethod(info); | 3482 TestObjectPythonV8Internal::voidMethodLongLongArgMethod(info); |
3483 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3483 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3484 } | 3484 } |
3485 | 3485 |
3486 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3486 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3487 { | 3487 { |
3488 if (UNLIKELY(info.Length() < 1)) { | 3488 if (info.Length() < 1) { |
3489 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOctetArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); | 3489 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOctetArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); |
3490 return; | 3490 return; |
3491 } | 3491 } |
3492 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3492 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3493 V8TRYCATCH_VOID(unsigned, octetArg, toUInt8(info[0])); | 3493 V8TRYCATCH_VOID(unsigned, octetArg, toUInt8(info[0])); |
3494 imp->voidMethodOctetArg(octetArg); | 3494 imp->voidMethodOctetArg(octetArg); |
3495 } | 3495 } |
3496 | 3496 |
3497 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3497 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3498 { | 3498 { |
3499 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3499 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3500 TestObjectPythonV8Internal::voidMethodOctetArgMethod(info); | 3500 TestObjectPythonV8Internal::voidMethodOctetArgMethod(info); |
3501 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3501 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3502 } | 3502 } |
3503 | 3503 |
3504 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3504 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3505 { | 3505 { |
3506 if (UNLIKELY(info.Length() < 1)) { | 3506 if (info.Length() < 1) { |
3507 throwTypeError(ExceptionMessages::failedToExecute("voidMethodShortArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); | 3507 throwTypeError(ExceptionMessages::failedToExecute("voidMethodShortArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); |
3508 return; | 3508 return; |
3509 } | 3509 } |
3510 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3510 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3511 V8TRYCATCH_VOID(int, shortArg, toInt16(info[0])); | 3511 V8TRYCATCH_VOID(int, shortArg, toInt16(info[0])); |
3512 imp->voidMethodShortArg(shortArg); | 3512 imp->voidMethodShortArg(shortArg); |
3513 } | 3513 } |
3514 | 3514 |
3515 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3515 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3516 { | 3516 { |
3517 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3517 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3518 TestObjectPythonV8Internal::voidMethodShortArgMethod(info); | 3518 TestObjectPythonV8Internal::voidMethodShortArgMethod(info); |
3519 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3519 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3520 } | 3520 } |
3521 | 3521 |
3522 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3522 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3523 { | 3523 { |
3524 if (UNLIKELY(info.Length() < 1)) { | 3524 if (info.Length() < 1) { |
3525 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); | 3525 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); |
3526 return; | 3526 return; |
3527 } | 3527 } |
3528 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3528 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3529 V8TRYCATCH_VOID(unsigned, unsignedLongArg, toUInt32(info[0])); | 3529 V8TRYCATCH_VOID(unsigned, unsignedLongArg, toUInt32(info[0])); |
3530 imp->voidMethodUnsignedLongArg(unsignedLongArg); | 3530 imp->voidMethodUnsignedLongArg(unsignedLongArg); |
3531 } | 3531 } |
3532 | 3532 |
3533 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 3533 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
3534 { | 3534 { |
3535 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3535 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3536 TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethod(info); | 3536 TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethod(info); |
3537 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3537 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3538 } | 3538 } |
3539 | 3539 |
3540 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) | 3540 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) |
3541 { | 3541 { |
3542 if (UNLIKELY(info.Length() < 1)) { | 3542 if (info.Length() < 1) { |
3543 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); | 3543 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); |
3544 return; | 3544 return; |
3545 } | 3545 } |
3546 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3546 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3547 V8TRYCATCH_VOID(unsigned long long, unsignedLongLongArg, toUInt64(info[0])); | 3547 V8TRYCATCH_VOID(unsigned long long, unsignedLongLongArg, toUInt64(info[0])); |
3548 imp->voidMethodUnsignedLongLongArg(unsignedLongLongArg); | 3548 imp->voidMethodUnsignedLongLongArg(unsignedLongLongArg); |
3549 } | 3549 } |
3550 | 3550 |
3551 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 3551 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
3552 { | 3552 { |
3553 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3553 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3554 TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethod(info); | 3554 TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethod(info); |
3555 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3555 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3556 } | 3556 } |
3557 | 3557 |
3558 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3558 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3559 { | 3559 { |
3560 if (UNLIKELY(info.Length() < 1)) { | 3560 if (info.Length() < 1) { |
3561 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedSho
rtArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length
())), info.GetIsolate()); | 3561 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedSho
rtArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length
())), info.GetIsolate()); |
3562 return; | 3562 return; |
3563 } | 3563 } |
3564 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3564 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3565 V8TRYCATCH_VOID(unsigned, unsignedShortArg, toUInt16(info[0])); | 3565 V8TRYCATCH_VOID(unsigned, unsignedShortArg, toUInt16(info[0])); |
3566 imp->voidMethodUnsignedShortArg(unsignedShortArg); | 3566 imp->voidMethodUnsignedShortArg(unsignedShortArg); |
3567 } | 3567 } |
3568 | 3568 |
3569 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 3569 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
3570 { | 3570 { |
(...skipping 10 matching lines...) Expand all Loading... |
3581 | 3581 |
3582 static void testInterfaceEmptyMethodMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 3582 static void testInterfaceEmptyMethodMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
3583 { | 3583 { |
3584 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3584 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3585 TestObjectPythonV8Internal::testInterfaceEmptyMethodMethod(info); | 3585 TestObjectPythonV8Internal::testInterfaceEmptyMethodMethod(info); |
3586 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3586 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3587 } | 3587 } |
3588 | 3588 |
3589 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 3589 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
3590 { | 3590 { |
3591 if (UNLIKELY(info.Length() < 1)) { | 3591 if (info.Length() < 1) { |
3592 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); | 3592 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); |
3593 return; | 3593 return; |
3594 } | 3594 } |
3595 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3595 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3596 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 3596 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
3597 imp->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); | 3597 imp->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); |
3598 } | 3598 } |
3599 | 3599 |
3600 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 3600 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
3601 { | 3601 { |
3602 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3602 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3603 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); | 3603 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); |
3604 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3604 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3605 } | 3605 } |
3606 | 3606 |
3607 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 3607 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
3608 { | 3608 { |
3609 if (UNLIKELY(info.Length() < 2)) { | 3609 if (info.Length() < 2) { |
3610 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgTest
InterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2,
info.Length())), info.GetIsolate()); | 3610 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgTest
InterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2,
info.Length())), info.GetIsolate()); |
3611 return; | 3611 return; |
3612 } | 3612 } |
3613 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3613 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3614 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 3614 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
3615 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); | 3615 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); |
3616 imp->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg); | 3616 imp->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg); |
3617 } | 3617 } |
3618 | 3618 |
3619 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 3619 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
(...skipping 24 matching lines...) Expand all Loading... |
3644 | 3644 |
3645 static void anyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3645 static void anyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3646 { | 3646 { |
3647 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3647 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3648 TestObjectPythonV8Internal::anyMethodMethod(info); | 3648 TestObjectPythonV8Internal::anyMethodMethod(info); |
3649 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3649 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3650 } | 3650 } |
3651 | 3651 |
3652 static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallback
Info<v8::Value>& info) | 3652 static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallback
Info<v8::Value>& info) |
3653 { | 3653 { |
3654 if (UNLIKELY(info.Length() < 1)) { | 3654 if (info.Length() < 1) { |
3655 throwTypeError(ExceptionMessages::failedToExecute("voidMethodMediaQueryL
istListenerArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, in
fo.Length())), info.GetIsolate()); | 3655 throwTypeError(ExceptionMessages::failedToExecute("voidMethodMediaQueryL
istListenerArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, in
fo.Length())), info.GetIsolate()); |
3656 return; | 3656 return; |
3657 } | 3657 } |
3658 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3658 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3659 V8TRYCATCH_VOID(RefPtr<MediaQueryListListener>, mediaQueryListListenerArg, M
ediaQueryListListener::create(ScriptValue(info[0], info.GetIsolate()))); | 3659 V8TRYCATCH_VOID(RefPtr<MediaQueryListListener>, mediaQueryListListenerArg, M
ediaQueryListListener::create(ScriptValue(info[0], info.GetIsolate()))); |
3660 imp->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg); | 3660 imp->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg); |
3661 } | 3661 } |
3662 | 3662 |
3663 static void voidMethodMediaQueryListListenerArgMethodCallback(const v8::Function
CallbackInfo<v8::Value>& info) | 3663 static void voidMethodMediaQueryListListenerArgMethodCallback(const v8::Function
CallbackInfo<v8::Value>& info) |
3664 { | 3664 { |
3665 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3665 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3666 TestObjectPythonV8Internal::voidMethodMediaQueryListListenerArgMethod(info); | 3666 TestObjectPythonV8Internal::voidMethodMediaQueryListListenerArgMethod(info); |
3667 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3667 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3668 } | 3668 } |
3669 | 3669 |
3670 static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 3670 static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
3671 { | 3671 { |
3672 if (UNLIKELY(info.Length() < 1)) { | 3672 if (info.Length() < 1) { |
3673 throwTypeError(ExceptionMessages::failedToExecute("voidMethodCompareHowA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); | 3673 throwTypeError(ExceptionMessages::failedToExecute("voidMethodCompareHowA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); |
3674 return; | 3674 return; |
3675 } | 3675 } |
3676 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3676 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3677 V8TRYCATCH_VOID(Range::CompareHow, compareHowArg, static_cast<Range::Compare
How>(info[0]->Int32Value())); | 3677 V8TRYCATCH_VOID(Range::CompareHow, compareHowArg, static_cast<Range::Compare
How>(info[0]->Int32Value())); |
3678 imp->voidMethodCompareHowArg(compareHowArg); | 3678 imp->voidMethodCompareHowArg(compareHowArg); |
3679 } | 3679 } |
3680 | 3680 |
3681 static void voidMethodCompareHowArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 3681 static void voidMethodCompareHowArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
3682 { | 3682 { |
3683 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3683 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3684 TestObjectPythonV8Internal::voidMethodCompareHowArgMethod(info); | 3684 TestObjectPythonV8Internal::voidMethodCompareHowArgMethod(info); |
3685 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3685 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3686 } | 3686 } |
3687 | 3687 |
3688 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in
fo) | 3688 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& in
fo) |
3689 { | 3689 { |
3690 if (UNLIKELY(info.Length() < 1)) { | 3690 if (info.Length() < 1) { |
3691 throwTypeError(ExceptionMessages::failedToExecute("voidMethodAnyArg", "T
estObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info
.GetIsolate()); | 3691 throwTypeError(ExceptionMessages::failedToExecute("voidMethodAnyArg", "T
estObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info
.GetIsolate()); |
3692 return; | 3692 return; |
3693 } | 3693 } |
3694 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3694 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3695 V8TRYCATCH_VOID(ScriptValue, anyArg, ScriptValue(info[0], info.GetIsolate())
); | 3695 V8TRYCATCH_VOID(ScriptValue, anyArg, ScriptValue(info[0], info.GetIsolate())
); |
3696 imp->voidMethodAnyArg(anyArg); | 3696 imp->voidMethodAnyArg(anyArg); |
3697 } | 3697 } |
3698 | 3698 |
3699 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 3699 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
3700 { | 3700 { |
3701 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3701 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3702 TestObjectPythonV8Internal::voidMethodAnyArgMethod(info); | 3702 TestObjectPythonV8Internal::voidMethodAnyArgMethod(info); |
3703 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3703 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3704 } | 3704 } |
3705 | 3705 |
3706 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3706 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3707 { | 3707 { |
3708 if (UNLIKELY(info.Length() < 1)) { | 3708 if (info.Length() < 1) { |
3709 throwTypeError(ExceptionMessages::failedToExecute("voidMethodAttrArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3709 throwTypeError(ExceptionMessages::failedToExecute("voidMethodAttrArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
3710 return; | 3710 return; |
3711 } | 3711 } |
3712 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3712 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3713 V8TRYCATCH_VOID(Attr*, attrArg, V8Attr::hasInstance(info[0], info.GetIsolate
(), worldType(info.GetIsolate())) ? V8Attr::toNative(v8::Handle<v8::Object>::Cas
t(info[0])) : 0); | 3713 V8TRYCATCH_VOID(Attr*, attrArg, V8Attr::hasInstance(info[0], info.GetIsolate
(), worldType(info.GetIsolate())) ? V8Attr::toNative(v8::Handle<v8::Object>::Cas
t(info[0])) : 0); |
3714 imp->voidMethodAttrArg(attrArg); | 3714 imp->voidMethodAttrArg(attrArg); |
3715 } | 3715 } |
3716 | 3716 |
3717 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3717 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3718 { | 3718 { |
3719 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3719 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3720 TestObjectPythonV8Internal::voidMethodAttrArgMethod(info); | 3720 TestObjectPythonV8Internal::voidMethodAttrArgMethod(info); |
3721 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3721 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3722 } | 3722 } |
3723 | 3723 |
3724 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 3724 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
3725 { | 3725 { |
3726 if (UNLIKELY(info.Length() < 1)) { | 3726 if (info.Length() < 1) { |
3727 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 3727 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
3728 return; | 3728 return; |
3729 } | 3729 } |
3730 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3730 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3731 V8TRYCATCH_VOID(Document*, documentArg, V8Document::hasInstance(info[0], inf
o.GetIsolate(), worldType(info.GetIsolate())) ? V8Document::toNative(v8::Handle<
v8::Object>::Cast(info[0])) : 0); | 3731 V8TRYCATCH_VOID(Document*, documentArg, V8Document::hasInstance(info[0], inf
o.GetIsolate(), worldType(info.GetIsolate())) ? V8Document::toNative(v8::Handle<
v8::Object>::Cast(info[0])) : 0); |
3732 imp->voidMethodDocumentArg(documentArg); | 3732 imp->voidMethodDocumentArg(documentArg); |
3733 } | 3733 } |
3734 | 3734 |
3735 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 3735 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
3736 { | 3736 { |
3737 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3737 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3738 TestObjectPythonV8Internal::voidMethodDocumentArgMethod(info); | 3738 TestObjectPythonV8Internal::voidMethodDocumentArgMethod(info); |
3739 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3739 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3740 } | 3740 } |
3741 | 3741 |
3742 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3742 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3743 { | 3743 { |
3744 if (UNLIKELY(info.Length() < 1)) { | 3744 if (info.Length() < 1) { |
3745 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentTyp
eArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); | 3745 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentTyp
eArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); |
3746 return; | 3746 return; |
3747 } | 3747 } |
3748 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3748 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3749 V8TRYCATCH_VOID(DocumentType*, documentTypeArg, V8DocumentType::hasInstance(
info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8DocumentType::toNa
tive(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 3749 V8TRYCATCH_VOID(DocumentType*, documentTypeArg, V8DocumentType::hasInstance(
info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8DocumentType::toNa
tive(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
3750 imp->voidMethodDocumentTypeArg(documentTypeArg); | 3750 imp->voidMethodDocumentTypeArg(documentTypeArg); |
3751 } | 3751 } |
3752 | 3752 |
3753 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 3753 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
3754 { | 3754 { |
3755 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3755 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3756 TestObjectPythonV8Internal::voidMethodDocumentTypeArgMethod(info); | 3756 TestObjectPythonV8Internal::voidMethodDocumentTypeArgMethod(info); |
3757 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3757 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3758 } | 3758 } |
3759 | 3759 |
3760 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 3760 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
3761 { | 3761 { |
3762 if (UNLIKELY(info.Length() < 1)) { | 3762 if (info.Length() < 1) { |
3763 throwTypeError(ExceptionMessages::failedToExecute("voidMethodElementArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 3763 throwTypeError(ExceptionMessages::failedToExecute("voidMethodElementArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
3764 return; | 3764 return; |
3765 } | 3765 } |
3766 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3766 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3767 V8TRYCATCH_VOID(Element*, elementArg, V8Element::hasInstance(info[0], info.G
etIsolate(), worldType(info.GetIsolate())) ? V8Element::toNative(v8::Handle<v8::
Object>::Cast(info[0])) : 0); | 3767 V8TRYCATCH_VOID(Element*, elementArg, V8Element::hasInstance(info[0], info.G
etIsolate(), worldType(info.GetIsolate())) ? V8Element::toNative(v8::Handle<v8::
Object>::Cast(info[0])) : 0); |
3768 imp->voidMethodElementArg(elementArg); | 3768 imp->voidMethodElementArg(elementArg); |
3769 } | 3769 } |
3770 | 3770 |
3771 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 3771 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
3772 { | 3772 { |
3773 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3773 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3774 TestObjectPythonV8Internal::voidMethodElementArgMethod(info); | 3774 TestObjectPythonV8Internal::voidMethodElementArgMethod(info); |
3775 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3775 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3776 } | 3776 } |
3777 | 3777 |
3778 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3778 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3779 { | 3779 { |
3780 if (UNLIKELY(info.Length() < 1)) { | 3780 if (info.Length() < 1) { |
3781 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3781 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
3782 return; | 3782 return; |
3783 } | 3783 } |
3784 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3784 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3785 V8TRYCATCH_VOID(Node*, nodeArg, V8Node::hasInstance(info[0], info.GetIsolate
(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cas
t(info[0])) : 0); | 3785 V8TRYCATCH_VOID(Node*, nodeArg, V8Node::hasInstance(info[0], info.GetIsolate
(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cas
t(info[0])) : 0); |
3786 imp->voidMethodNodeArg(nodeArg); | 3786 imp->voidMethodNodeArg(nodeArg); |
3787 } | 3787 } |
3788 | 3788 |
3789 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3789 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3790 { | 3790 { |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3853 | 3853 |
3854 static void uint8ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 3854 static void uint8ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
3855 { | 3855 { |
3856 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3856 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3857 TestObjectPythonV8Internal::uint8ArrayMethodMethod(info); | 3857 TestObjectPythonV8Internal::uint8ArrayMethodMethod(info); |
3858 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3858 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3859 } | 3859 } |
3860 | 3860 |
3861 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 3861 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
3862 { | 3862 { |
3863 if (UNLIKELY(info.Length() < 1)) { | 3863 if (info.Length() < 1) { |
3864 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBuffer
Arg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()
)), info.GetIsolate()); | 3864 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBuffer
Arg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()
)), info.GetIsolate()); |
3865 return; | 3865 return; |
3866 } | 3866 } |
3867 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3867 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3868 V8TRYCATCH_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8A
rrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); | 3868 V8TRYCATCH_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8A
rrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0); |
3869 imp->voidMethodArrayBufferArg(arrayBufferArg); | 3869 imp->voidMethodArrayBufferArg(arrayBufferArg); |
3870 } | 3870 } |
3871 | 3871 |
3872 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 3872 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
3873 { | 3873 { |
3874 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3874 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3875 TestObjectPythonV8Internal::voidMethodArrayBufferArgMethod(info); | 3875 TestObjectPythonV8Internal::voidMethodArrayBufferArgMethod(info); |
3876 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3876 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3877 } | 3877 } |
3878 | 3878 |
3879 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) | 3879 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) |
3880 { | 3880 { |
3881 if (UNLIKELY(info.Length() < 1)) { | 3881 if (info.Length() < 1) { |
3882 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBuffer
ViewArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Leng
th())), info.GetIsolate()); | 3882 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBuffer
ViewArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Leng
th())), info.GetIsolate()); |
3883 return; | 3883 return; |
3884 } | 3884 } |
3885 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3885 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3886 V8TRYCATCH_VOID(ArrayBufferView*, arrayBufferViewArg, info[0]->IsArrayBuffer
View() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[
0])) : 0); | 3886 V8TRYCATCH_VOID(ArrayBufferView*, arrayBufferViewArg, info[0]->IsArrayBuffer
View() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[
0])) : 0); |
3887 imp->voidMethodArrayBufferViewArg(arrayBufferViewArg); | 3887 imp->voidMethodArrayBufferViewArg(arrayBufferViewArg); |
3888 } | 3888 } |
3889 | 3889 |
3890 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 3890 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
3891 { | 3891 { |
3892 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3892 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3893 TestObjectPythonV8Internal::voidMethodArrayBufferViewArgMethod(info); | 3893 TestObjectPythonV8Internal::voidMethodArrayBufferViewArgMethod(info); |
3894 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3894 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3895 } | 3895 } |
3896 | 3896 |
3897 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3897 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3898 { | 3898 { |
3899 if (UNLIKELY(info.Length() < 1)) { | 3899 if (info.Length() < 1) { |
3900 throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloat32Arra
yArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); | 3900 throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloat32Arra
yArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); |
3901 return; | 3901 return; |
3902 } | 3902 } |
3903 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3903 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3904 V8TRYCATCH_VOID(Float32Array*, float32ArrayArg, info[0]->IsFloat32Array() ?
V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0); | 3904 V8TRYCATCH_VOID(Float32Array*, float32ArrayArg, info[0]->IsFloat32Array() ?
V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0); |
3905 imp->voidMethodFloat32ArrayArg(float32ArrayArg); | 3905 imp->voidMethodFloat32ArrayArg(float32ArrayArg); |
3906 } | 3906 } |
3907 | 3907 |
3908 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 3908 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
3909 { | 3909 { |
3910 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3910 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3911 TestObjectPythonV8Internal::voidMethodFloat32ArrayArgMethod(info); | 3911 TestObjectPythonV8Internal::voidMethodFloat32ArrayArgMethod(info); |
3912 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3912 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3913 } | 3913 } |
3914 | 3914 |
3915 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 3915 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
3916 { | 3916 { |
3917 if (UNLIKELY(info.Length() < 1)) { | 3917 if (info.Length() < 1) { |
3918 throwTypeError(ExceptionMessages::failedToExecute("voidMethodInt32ArrayA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); | 3918 throwTypeError(ExceptionMessages::failedToExecute("voidMethodInt32ArrayA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); |
3919 return; | 3919 return; |
3920 } | 3920 } |
3921 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3921 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3922 V8TRYCATCH_VOID(Int32Array*, int32ArrayArg, info[0]->IsInt32Array() ? V8Int3
2Array::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0); | 3922 V8TRYCATCH_VOID(Int32Array*, int32ArrayArg, info[0]->IsInt32Array() ? V8Int3
2Array::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0); |
3923 imp->voidMethodInt32ArrayArg(int32ArrayArg); | 3923 imp->voidMethodInt32ArrayArg(int32ArrayArg); |
3924 } | 3924 } |
3925 | 3925 |
3926 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 3926 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
3927 { | 3927 { |
3928 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3928 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3929 TestObjectPythonV8Internal::voidMethodInt32ArrayArgMethod(info); | 3929 TestObjectPythonV8Internal::voidMethodInt32ArrayArgMethod(info); |
3930 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3930 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3931 } | 3931 } |
3932 | 3932 |
3933 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 3933 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
3934 { | 3934 { |
3935 if (UNLIKELY(info.Length() < 1)) { | 3935 if (info.Length() < 1) { |
3936 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUint8ArrayA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); | 3936 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUint8ArrayA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); |
3937 return; | 3937 return; |
3938 } | 3938 } |
3939 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3939 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3940 V8TRYCATCH_VOID(Uint8Array*, uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint
8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0); | 3940 V8TRYCATCH_VOID(Uint8Array*, uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint
8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0); |
3941 imp->voidMethodUint8ArrayArg(uint8ArrayArg); | 3941 imp->voidMethodUint8ArrayArg(uint8ArrayArg); |
3942 } | 3942 } |
3943 | 3943 |
3944 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 3944 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
3945 { | 3945 { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3982 | 3982 |
3983 static void testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 3983 static void testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
3984 { | 3984 { |
3985 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3985 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3986 TestObjectPythonV8Internal::testInterfaceEmptyArrayMethodMethod(info); | 3986 TestObjectPythonV8Internal::testInterfaceEmptyArrayMethodMethod(info); |
3987 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3987 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3988 } | 3988 } |
3989 | 3989 |
3990 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) | 3990 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) |
3991 { | 3991 { |
3992 if (UNLIKELY(info.Length() < 1)) { | 3992 if (info.Length() < 1) { |
3993 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayLongAr
g", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()))
, info.GetIsolate()); | 3993 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayLongAr
g", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()))
, info.GetIsolate()); |
3994 return; | 3994 return; |
3995 } | 3995 } |
3996 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3996 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3997 V8TRYCATCH_VOID(Vector<int>, arrayLongArg, toNativeArray<int>(info[0], 1, in
fo.GetIsolate())); | 3997 V8TRYCATCH_VOID(Vector<int>, arrayLongArg, toNativeArray<int>(info[0], 1, in
fo.GetIsolate())); |
3998 imp->voidMethodArrayLongArg(arrayLongArg); | 3998 imp->voidMethodArrayLongArg(arrayLongArg); |
3999 } | 3999 } |
4000 | 4000 |
4001 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<
v8::Value>& info) | 4001 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<
v8::Value>& info) |
4002 { | 4002 { |
4003 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4003 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4004 TestObjectPythonV8Internal::voidMethodArrayLongArgMethod(info); | 4004 TestObjectPythonV8Internal::voidMethodArrayLongArgMethod(info); |
4005 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4005 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4006 } | 4006 } |
4007 | 4007 |
4008 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) | 4008 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Va
lue>& info) |
4009 { | 4009 { |
4010 if (UNLIKELY(info.Length() < 1)) { | 4010 if (info.Length() < 1) { |
4011 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayString
Arg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()
)), info.GetIsolate()); | 4011 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayString
Arg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()
)), info.GetIsolate()); |
4012 return; | 4012 return; |
4013 } | 4013 } |
4014 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4014 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4015 V8TRYCATCH_VOID(Vector<String>, arrayStringArg, toNativeArray<String>(info[0
], 1, info.GetIsolate())); | 4015 V8TRYCATCH_VOID(Vector<String>, arrayStringArg, toNativeArray<String>(info[0
], 1, info.GetIsolate())); |
4016 imp->voidMethodArrayStringArg(arrayStringArg); | 4016 imp->voidMethodArrayStringArg(arrayStringArg); |
4017 } | 4017 } |
4018 | 4018 |
4019 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) | 4019 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInf
o<v8::Value>& info) |
4020 { | 4020 { |
4021 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4021 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4022 TestObjectPythonV8Internal::voidMethodArrayStringArgMethod(info); | 4022 TestObjectPythonV8Internal::voidMethodArrayStringArgMethod(info); |
4023 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4023 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4024 } | 4024 } |
4025 | 4025 |
4026 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 4026 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
4027 { | 4027 { |
4028 if (UNLIKELY(info.Length() < 1)) { | 4028 if (info.Length() < 1) { |
4029 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayTestIn
terfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, i
nfo.Length())), info.GetIsolate()); | 4029 throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayTestIn
terfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, i
nfo.Length())), info.GetIsolate()); |
4030 return; | 4030 return; |
4031 } | 4031 } |
4032 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4032 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4033 V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, arrayTestInterfaceEmpty
Arg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1,
info.GetIsolate()))); | 4033 V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, arrayTestInterfaceEmpty
Arg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1,
info.GetIsolate()))); |
4034 imp->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg); | 4034 imp->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg); |
4035 } | 4035 } |
4036 | 4036 |
4037 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 4037 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
4038 { | 4038 { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4075 | 4075 |
4076 static void sequenceTestInterfaceEmptyMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 4076 static void sequenceTestInterfaceEmptyMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
4077 { | 4077 { |
4078 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4078 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4079 TestObjectPythonV8Internal::sequenceTestInterfaceEmptyMethodMethod(info); | 4079 TestObjectPythonV8Internal::sequenceTestInterfaceEmptyMethodMethod(info); |
4080 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4080 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4081 } | 4081 } |
4082 | 4082 |
4083 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4083 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4084 { | 4084 { |
4085 if (UNLIKELY(info.Length() < 1)) { | 4085 if (info.Length() < 1) { |
4086 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceLon
gArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); | 4086 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceLon
gArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); |
4087 return; | 4087 return; |
4088 } | 4088 } |
4089 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4089 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4090 V8TRYCATCH_VOID(Vector<int>, sequenceLongArg, toNativeArray<int>(info[0], 1,
info.GetIsolate())); | 4090 V8TRYCATCH_VOID(Vector<int>, sequenceLongArg, toNativeArray<int>(info[0], 1,
info.GetIsolate())); |
4091 imp->voidMethodSequenceLongArg(sequenceLongArg); | 4091 imp->voidMethodSequenceLongArg(sequenceLongArg); |
4092 } | 4092 } |
4093 | 4093 |
4094 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 4094 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
4095 { | 4095 { |
4096 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4096 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4097 TestObjectPythonV8Internal::voidMethodSequenceLongArgMethod(info); | 4097 TestObjectPythonV8Internal::voidMethodSequenceLongArgMethod(info); |
4098 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4098 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4099 } | 4099 } |
4100 | 4100 |
4101 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 4101 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
4102 { | 4102 { |
4103 if (UNLIKELY(info.Length() < 1)) { | 4103 if (info.Length() < 1) { |
4104 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceStr
ingArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Lengt
h())), info.GetIsolate()); | 4104 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceStr
ingArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Lengt
h())), info.GetIsolate()); |
4105 return; | 4105 return; |
4106 } | 4106 } |
4107 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4107 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4108 V8TRYCATCH_VOID(Vector<String>, sequenceStringArg, toNativeArray<String>(inf
o[0], 1, info.GetIsolate())); | 4108 V8TRYCATCH_VOID(Vector<String>, sequenceStringArg, toNativeArray<String>(inf
o[0], 1, info.GetIsolate())); |
4109 imp->voidMethodSequenceStringArg(sequenceStringArg); | 4109 imp->voidMethodSequenceStringArg(sequenceStringArg); |
4110 } | 4110 } |
4111 | 4111 |
4112 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 4112 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
4113 { | 4113 { |
4114 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4114 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4115 TestObjectPythonV8Internal::voidMethodSequenceStringArgMethod(info); | 4115 TestObjectPythonV8Internal::voidMethodSequenceStringArgMethod(info); |
4116 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4116 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4117 } | 4117 } |
4118 | 4118 |
4119 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 4119 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
4120 { | 4120 { |
4121 if (UNLIKELY(info.Length() < 1)) { | 4121 if (info.Length() < 1) { |
4122 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceTes
tInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1
, info.Length())), info.GetIsolate()); | 4122 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceTes
tInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1
, info.Length())), info.GetIsolate()); |
4123 return; | 4123 return; |
4124 } | 4124 } |
4125 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4125 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4126 V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, sequenceTestInterfaceEm
ptyArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0],
1, info.GetIsolate()))); | 4126 V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, sequenceTestInterfaceEm
ptyArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0],
1, info.GetIsolate()))); |
4127 imp->voidMethodSequenceTestInterfaceEmptyArg(sequenceTestInterfaceEmptyArg); | 4127 imp->voidMethodSequenceTestInterfaceEmptyArg(sequenceTestInterfaceEmptyArg); |
4128 } | 4128 } |
4129 | 4129 |
4130 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4130 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4131 { | 4131 { |
4132 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4132 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4133 TestObjectPythonV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(in
fo); | 4133 TestObjectPythonV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(in
fo); |
4134 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4134 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4135 } | 4135 } |
4136 | 4136 |
4137 static void voidMethodNullableStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 4137 static void voidMethodNullableStringArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
4138 { | 4138 { |
4139 if (UNLIKELY(info.Length() < 1)) { | 4139 if (info.Length() < 1) { |
4140 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNullableStr
ingArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Lengt
h())), info.GetIsolate()); | 4140 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNullableStr
ingArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Lengt
h())), info.GetIsolate()); |
4141 return; | 4141 return; |
4142 } | 4142 } |
4143 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4143 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4144 V8TRYCATCH_VOID(TestInterfaceEmpty*, nullableTestInterfaceEmptyArg, V8TestIn
terfaceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate(
))) ? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0)
; | 4144 V8TRYCATCH_VOID(TestInterfaceEmpty*, nullableTestInterfaceEmptyArg, V8TestIn
terfaceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate(
))) ? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0)
; |
4145 imp->voidMethodNullableStringArg(nullableTestInterfaceEmptyArg); | 4145 imp->voidMethodNullableStringArg(nullableTestInterfaceEmptyArg); |
4146 } | 4146 } |
4147 | 4147 |
4148 static void voidMethodNullableStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 4148 static void voidMethodNullableStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
4149 { | 4149 { |
(...skipping 10 matching lines...) Expand all Loading... |
4160 | 4160 |
4161 static void testEnumMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Valu
e>& info) | 4161 static void testEnumMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Valu
e>& info) |
4162 { | 4162 { |
4163 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4163 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4164 TestObjectPythonV8Internal::testEnumMethodMethod(info); | 4164 TestObjectPythonV8Internal::testEnumMethodMethod(info); |
4165 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4165 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4166 } | 4166 } |
4167 | 4167 |
4168 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 4168 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
4169 { | 4169 { |
4170 if (UNLIKELY(info.Length() < 1)) { | 4170 if (info.Length() < 1) { |
4171 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 4171 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
4172 return; | 4172 return; |
4173 } | 4173 } |
4174 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4174 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4175 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, testEnumTypeArg, in
fo[0]); | 4175 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, testEnumTypeArg, in
fo[0]); |
4176 String string = testEnumTypeArg; | 4176 String string = testEnumTypeArg; |
4177 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || st
ring == "EnumValue3")) { | 4177 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || st
ring == "EnumValue3")) { |
4178 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg
", "TestObjectPython", "parameter 1 ('" + string + "') is not a valid enum value
."), info.GetIsolate()); | 4178 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg
", "TestObjectPython", "parameter 1 ('" + string + "') is not a valid enum value
."), info.GetIsolate()); |
4179 return; | 4179 return; |
4180 } | 4180 } |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4248 | 4248 |
4249 static void xPathNSResolverMethodMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 4249 static void xPathNSResolverMethodMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
4250 { | 4250 { |
4251 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4251 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4252 TestObjectPythonV8Internal::xPathNSResolverMethodMethod(info); | 4252 TestObjectPythonV8Internal::xPathNSResolverMethodMethod(info); |
4253 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4253 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4254 } | 4254 } |
4255 | 4255 |
4256 static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 4256 static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
4257 { | 4257 { |
4258 if (UNLIKELY(info.Length() < 1)) { | 4258 if (info.Length() < 1) { |
4259 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); | 4259 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); |
4260 return; | 4260 return; |
4261 } | 4261 } |
4262 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4262 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4263 V8TRYCATCH_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsola
te())); | 4263 V8TRYCATCH_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsola
te())); |
4264 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) { | 4264 if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) { |
4265 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryA
rg", "TestObjectPython", "parameter 1 ('dictionaryArg') is not an object."), inf
o.GetIsolate()); | 4265 throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryA
rg", "TestObjectPython", "parameter 1 ('dictionaryArg') is not an object."), inf
o.GetIsolate()); |
4266 return; | 4266 return; |
4267 } | 4267 } |
4268 imp->voidMethodDictionaryArg(dictionaryArg); | 4268 imp->voidMethodDictionaryArg(dictionaryArg); |
4269 } | 4269 } |
4270 | 4270 |
4271 static void voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 4271 static void voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
4272 { | 4272 { |
4273 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4273 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4274 TestObjectPythonV8Internal::voidMethodDictionaryArgMethod(info); | 4274 TestObjectPythonV8Internal::voidMethodDictionaryArgMethod(info); |
4275 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4275 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4276 } | 4276 } |
4277 | 4277 |
4278 static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 4278 static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
4279 { | 4279 { |
4280 if (UNLIKELY(info.Length() < 1)) { | 4280 if (info.Length() < 1) { |
4281 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeFilterA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); | 4281 throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeFilterA
rg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())
), info.GetIsolate()); |
4282 return; | 4282 return; |
4283 } | 4283 } |
4284 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4284 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4285 V8TRYCATCH_VOID(RefPtr<NodeFilter>, nodeFilterArg, toNodeFilter(info[0], inf
o.GetIsolate())); | 4285 V8TRYCATCH_VOID(RefPtr<NodeFilter>, nodeFilterArg, toNodeFilter(info[0], inf
o.GetIsolate())); |
4286 imp->voidMethodNodeFilterArg(nodeFilterArg.release()); | 4286 imp->voidMethodNodeFilterArg(nodeFilterArg.release()); |
4287 } | 4287 } |
4288 | 4288 |
4289 static void voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) | 4289 static void voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo
<v8::Value>& info) |
4290 { | 4290 { |
4291 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4291 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4292 TestObjectPythonV8Internal::voidMethodNodeFilterArgMethod(info); | 4292 TestObjectPythonV8Internal::voidMethodNodeFilterArgMethod(info); |
4293 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4293 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4294 } | 4294 } |
4295 | 4295 |
4296 static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) | 4296 static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value>
& info) |
4297 { | 4297 { |
4298 if (UNLIKELY(info.Length() < 1)) { | 4298 if (info.Length() < 1) { |
4299 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 4299 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg"
, "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); |
4300 return; | 4300 return; |
4301 } | 4301 } |
4302 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4302 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4303 V8TRYCATCH_VOID(ScriptPromise, promiseArg, ScriptPromise(info[0])); | 4303 V8TRYCATCH_VOID(ScriptPromise, promiseArg, ScriptPromise(info[0])); |
4304 if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) { | 4304 if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) { |
4305 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg"
, "TestObjectPython", "parameter 1 ('promiseArg') is not an object."), info.GetI
solate()); | 4305 throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg"
, "TestObjectPython", "parameter 1 ('promiseArg') is not an object."), info.GetI
solate()); |
4306 return; | 4306 return; |
4307 } | 4307 } |
4308 imp->voidMethodPromiseArg(promiseArg); | 4308 imp->voidMethodPromiseArg(promiseArg); |
4309 } | 4309 } |
4310 | 4310 |
4311 static void voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 4311 static void voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
4312 { | 4312 { |
4313 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4313 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4314 TestObjectPythonV8Internal::voidMethodPromiseArgMethod(info); | 4314 TestObjectPythonV8Internal::voidMethodPromiseArgMethod(info); |
4315 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4315 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4316 } | 4316 } |
4317 | 4317 |
4318 static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 4318 static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
4319 { | 4319 { |
4320 if (UNLIKELY(info.Length() < 1)) { | 4320 if (info.Length() < 1) { |
4321 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSerializedS
criptValueArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, inf
o.Length())), info.GetIsolate()); | 4321 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSerializedS
criptValueArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, inf
o.Length())), info.GetIsolate()); |
4322 return; | 4322 return; |
4323 } | 4323 } |
4324 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4324 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4325 bool serializedScriptValueArgDidThrow = false; | 4325 bool serializedScriptValueArgDidThrow = false; |
4326 RefPtr<SerializedScriptValue> serializedScriptValueArg = SerializedScriptVal
ue::create(info[0], 0, 0, serializedScriptValueArgDidThrow, info.GetIsolate()); | 4326 RefPtr<SerializedScriptValue> serializedScriptValueArg = SerializedScriptVal
ue::create(info[0], 0, 0, serializedScriptValueArgDidThrow, info.GetIsolate()); |
4327 if (serializedScriptValueArgDidThrow) | 4327 if (serializedScriptValueArgDidThrow) |
4328 return; | 4328 return; |
4329 imp->voidMethodSerializedScriptValueArg(serializedScriptValueArg); | 4329 imp->voidMethodSerializedScriptValueArg(serializedScriptValueArg); |
4330 } | 4330 } |
4331 | 4331 |
4332 static void voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionC
allbackInfo<v8::Value>& info) | 4332 static void voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionC
allbackInfo<v8::Value>& info) |
4333 { | 4333 { |
4334 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4334 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4335 TestObjectPythonV8Internal::voidMethodSerializedScriptValueArgMethod(info); | 4335 TestObjectPythonV8Internal::voidMethodSerializedScriptValueArgMethod(info); |
4336 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4336 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4337 } | 4337 } |
4338 | 4338 |
4339 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) | 4339 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8
::Value>& info) |
4340 { | 4340 { |
4341 if (UNLIKELY(info.Length() < 1)) { | 4341 if (info.Length() < 1) { |
4342 throwTypeError(ExceptionMessages::failedToExecute("voidMethodXPathNSReso
lverArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Leng
th())), info.GetIsolate()); | 4342 throwTypeError(ExceptionMessages::failedToExecute("voidMethodXPathNSReso
lverArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Leng
th())), info.GetIsolate()); |
4343 return; | 4343 return; |
4344 } | 4344 } |
4345 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4345 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4346 V8TRYCATCH_VOID(RefPtr<XPathNSResolver>, xPathNSResolverArg, toXPathNSResolv
er(info[0], info.GetIsolate())); | 4346 V8TRYCATCH_VOID(RefPtr<XPathNSResolver>, xPathNSResolverArg, toXPathNSResolv
er(info[0], info.GetIsolate())); |
4347 imp->voidMethodXPathNSResolverArg(xPathNSResolverArg.release()); | 4347 imp->voidMethodXPathNSResolverArg(xPathNSResolverArg.release()); |
4348 } | 4348 } |
4349 | 4349 |
4350 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 4350 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
4351 { | 4351 { |
4352 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4352 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4353 TestObjectPythonV8Internal::voidMethodXPathNSResolverArgMethod(info); | 4353 TestObjectPythonV8Internal::voidMethodXPathNSResolverArgMethod(info); |
4354 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4354 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4355 } | 4355 } |
4356 | 4356 |
4357 static void voidMethodSequenceDictionaryArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 4357 static void voidMethodSequenceDictionaryArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
4358 { | 4358 { |
4359 if (UNLIKELY(info.Length() < 1)) { | 4359 if (info.Length() < 1) { |
4360 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceDic
tionaryArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); | 4360 throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceDic
tionaryArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); |
4361 return; | 4361 return; |
4362 } | 4362 } |
4363 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4363 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4364 V8TRYCATCH_VOID(Vector<Dictionary>, sequenceDictionaryArg, toNativeArray<Dic
tionary>(info[0], 1, info.GetIsolate())); | 4364 V8TRYCATCH_VOID(Vector<Dictionary>, sequenceDictionaryArg, toNativeArray<Dic
tionary>(info[0], 1, info.GetIsolate())); |
4365 imp->voidMethodSequenceDictionaryArg(sequenceDictionaryArg); | 4365 imp->voidMethodSequenceDictionaryArg(sequenceDictionaryArg); |
4366 } | 4366 } |
4367 | 4367 |
4368 static void voidMethodSequenceDictionaryArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 4368 static void voidMethodSequenceDictionaryArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
4369 { | 4369 { |
4370 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4370 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4371 TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethod(info); | 4371 TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethod(info); |
4372 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4372 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4373 } | 4373 } |
4374 | 4374 |
4375 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) | 4375 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) |
4376 { | 4376 { |
4377 if (UNLIKELY(info.Length() < 2)) { | 4377 if (info.Length() < 2) { |
4378 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgLo
ngArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length
())), info.GetIsolate()); | 4378 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgLo
ngArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length
())), info.GetIsolate()); |
4379 return; | 4379 return; |
4380 } | 4380 } |
4381 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4381 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4382 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; | 4382 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; |
4383 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); | 4383 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); |
4384 imp->voidMethodStringArgLongArg(stringArg, longArg); | 4384 imp->voidMethodStringArgLongArg(stringArg, longArg); |
4385 } | 4385 } |
4386 | 4386 |
4387 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 4387 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4494 | 4494 |
4495 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 4495 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
4496 { | 4496 { |
4497 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4497 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4498 TestObjectPythonV8Internal::longMethodOptionalLongArgMethod(info); | 4498 TestObjectPythonV8Internal::longMethodOptionalLongArgMethod(info); |
4499 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4499 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4500 } | 4500 } |
4501 | 4501 |
4502 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) | 4502 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) |
4503 { | 4503 { |
4504 if (UNLIKELY(info.Length() < 1)) { | 4504 if (info.Length() < 1) { |
4505 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 4505 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); |
4506 return; | 4506 return; |
4507 } | 4507 } |
4508 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4508 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4509 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4509 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4510 if (UNLIKELY(info.Length() <= 1)) { | 4510 if (UNLIKELY(info.Length() <= 1)) { |
4511 imp->voidMethodLongArgOptionalLongArg(longArg); | 4511 imp->voidMethodLongArgOptionalLongArg(longArg); |
4512 return; | 4512 return; |
4513 } | 4513 } |
4514 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[1])); | 4514 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[1])); |
4515 imp->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg); | 4515 imp->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg); |
4516 } | 4516 } |
4517 | 4517 |
4518 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 4518 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
4519 { | 4519 { |
4520 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4520 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4521 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethod(info); | 4521 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethod(info); |
4522 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4522 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4523 } | 4523 } |
4524 | 4524 |
4525 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4525 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4526 { | 4526 { |
4527 if (UNLIKELY(info.Length() < 1)) { | 4527 if (info.Length() < 1) { |
4528 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); | 4528 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); |
4529 return; | 4529 return; |
4530 } | 4530 } |
4531 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4531 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4532 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4532 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4533 if (UNLIKELY(info.Length() <= 1)) { | 4533 if (UNLIKELY(info.Length() <= 1)) { |
4534 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg); | 4534 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg); |
4535 return; | 4535 return; |
4536 } | 4536 } |
4537 V8TRYCATCH_VOID(int, optionalLongArg1, toInt32(info[1])); | 4537 V8TRYCATCH_VOID(int, optionalLongArg1, toInt32(info[1])); |
4538 if (UNLIKELY(info.Length() <= 2)) { | 4538 if (UNLIKELY(info.Length() <= 2)) { |
4539 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLo
ngArg1); | 4539 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLo
ngArg1); |
4540 return; | 4540 return; |
4541 } | 4541 } |
4542 V8TRYCATCH_VOID(int, optionalLongArg2, toInt32(info[2])); | 4542 V8TRYCATCH_VOID(int, optionalLongArg2, toInt32(info[2])); |
4543 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongAr
g1, optionalLongArg2); | 4543 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongAr
g1, optionalLongArg2); |
4544 } | 4544 } |
4545 | 4545 |
4546 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 4546 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
4547 { | 4547 { |
4548 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4548 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4549 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgM
ethod(info); | 4549 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgM
ethod(info); |
4550 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4550 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4551 } | 4551 } |
4552 | 4552 |
4553 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 4553 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
4554 { | 4554 { |
4555 if (UNLIKELY(info.Length() < 1)) { | 4555 if (info.Length() < 1) { |
4556 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); | 4556 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); |
4557 return; | 4557 return; |
4558 } | 4558 } |
4559 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4559 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4560 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4560 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4561 if (UNLIKELY(info.Length() <= 1)) { | 4561 if (UNLIKELY(info.Length() <= 1)) { |
4562 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); | 4562 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); |
4563 return; | 4563 return; |
4564 } | 4564 } |
4565 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); | 4565 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); |
4566 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInt
erfaceEmpty); | 4566 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInt
erfaceEmpty); |
4567 } | 4567 } |
4568 | 4568 |
4569 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 4569 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
4570 { | 4570 { |
4571 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4571 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4572 TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMe
thod(info); | 4572 TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMe
thod(info); |
4573 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4573 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4574 } | 4574 } |
4575 | 4575 |
4576 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 4576 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
4577 { | 4577 { |
4578 if (UNLIKELY(info.Length() < 1)) { | 4578 if (info.Length() < 1) { |
4579 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); | 4579 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); |
4580 return; | 4580 return; |
4581 } | 4581 } |
4582 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4582 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4583 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 4583 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
4584 if (UNLIKELY(info.Length() <= 1)) { | 4584 if (UNLIKELY(info.Length() <= 1)) { |
4585 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfac
eEmpty); | 4585 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfac
eEmpty); |
4586 return; | 4586 return; |
4587 } | 4587 } |
4588 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); | 4588 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4623 | 4623 |
4624 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 4624 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
4625 { | 4625 { |
4626 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4626 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4627 TestObjectPythonV8Internal::voidMethodVariadicStringArgMethod(info); | 4627 TestObjectPythonV8Internal::voidMethodVariadicStringArgMethod(info); |
4628 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4628 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4629 } | 4629 } |
4630 | 4630 |
4631 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) | 4631 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbac
kInfo<v8::Value>& info) |
4632 { | 4632 { |
4633 if (UNLIKELY(info.Length() < 1)) { | 4633 if (info.Length() < 1) { |
4634 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgVa
riadicStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, i
nfo.Length())), info.GetIsolate()); | 4634 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgVa
riadicStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, i
nfo.Length())), info.GetIsolate()); |
4635 return; | 4635 return; |
4636 } | 4636 } |
4637 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4637 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4638 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; | 4638 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; |
4639 V8TRYCATCH_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String
>(info, 1)); | 4639 V8TRYCATCH_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String
>(info, 1)); |
4640 imp->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs); | 4640 imp->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs); |
4641 } | 4641 } |
4642 | 4642 |
4643 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 4643 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
(...skipping 19 matching lines...) Expand all Loading... |
4663 | 4663 |
4664 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4664 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4665 { | 4665 { |
4666 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4666 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4667 TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(in
fo); | 4667 TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(in
fo); |
4668 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4668 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4669 } | 4669 } |
4670 | 4670 |
4671 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 4671 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
4672 { | 4672 { |
4673 if (UNLIKELY(info.Length() < 1)) { | 4673 if (info.Length() < 1) { |
4674 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages:
:notEnoughArguments(1, info.Length())), info.GetIsolate()); | 4674 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages:
:notEnoughArguments(1, info.Length())), info.GetIsolate()); |
4675 return; | 4675 return; |
4676 } | 4676 } |
4677 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4677 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4678 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 4678 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
4679 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; | 4679 Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs; |
4680 for (int i = 1; i < info.Length(); ++i) { | 4680 for (int i = 1; i < info.Length(); ++i) { |
4681 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate(), world
Type(info.GetIsolate()))) { | 4681 if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate(), world
Type(info.GetIsolate()))) { |
4682 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInt
erfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", "parameter 2 i
s not of type 'TestInterfaceEmpty'."), info.GetIsolate()); | 4682 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInt
erfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", "parameter 2 i
s not of type 'TestInterfaceEmpty'."), info.GetIsolate()); |
4683 return; | 4683 return; |
4684 } | 4684 } |
4685 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8:
:Handle<v8::Object>::Cast(info[i]))); | 4685 variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8:
:Handle<v8::Object>::Cast(info[i]))); |
4686 } | 4686 } |
4687 imp->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInterf
aceEmptyArg, variadicTestInterfaceEmptyArgs); | 4687 imp->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInterf
aceEmptyArg, variadicTestInterfaceEmptyArgs); |
4688 } | 4688 } |
4689 | 4689 |
4690 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) | 4690 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) |
4691 { | 4691 { |
4692 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4692 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4693 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInter
faceEmptyArgMethod(info); | 4693 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInter
faceEmptyArgMethod(info); |
4694 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4694 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4695 } | 4695 } |
4696 | 4696 |
4697 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4697 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4698 { | 4698 { |
4699 if (UNLIKELY(info.Length() < 1)) { | 4699 if (info.Length() < 1) { |
4700 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4700 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4701 return; | 4701 return; |
4702 } | 4702 } |
4703 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4703 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4704 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4704 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4705 imp->overloadedMethodA(longArg); | 4705 imp->overloadedMethodA(longArg); |
4706 } | 4706 } |
4707 | 4707 |
4708 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4708 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4709 { | 4709 { |
4710 if (UNLIKELY(info.Length() < 2)) { | 4710 if (info.Length() < 2) { |
4711 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length())), inf
o.GetIsolate()); | 4711 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length())), inf
o.GetIsolate()); |
4712 return; | 4712 return; |
4713 } | 4713 } |
4714 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4714 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4715 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 4715 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); |
4716 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 4716 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); |
4717 imp->overloadedMethodA(longArg1, longArg2); | 4717 imp->overloadedMethodA(longArg1, longArg2); |
4718 } | 4718 } |
4719 | 4719 |
4720 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4720 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
(...skipping 18 matching lines...) Expand all Loading... |
4739 | 4739 |
4740 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4740 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4741 { | 4741 { |
4742 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4742 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4743 TestObjectPythonV8Internal::overloadedMethodAMethod(info); | 4743 TestObjectPythonV8Internal::overloadedMethodAMethod(info); |
4744 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4744 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4745 } | 4745 } |
4746 | 4746 |
4747 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4747 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4748 { | 4748 { |
4749 if (UNLIKELY(info.Length() < 1)) { | 4749 if (info.Length() < 1) { |
4750 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4750 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4751 return; | 4751 return; |
4752 } | 4752 } |
4753 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4753 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4754 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4754 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4755 imp->overloadedMethodB(longArg); | 4755 imp->overloadedMethodB(longArg); |
4756 } | 4756 } |
4757 | 4757 |
4758 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4758 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4759 { | 4759 { |
4760 if (UNLIKELY(info.Length() < 1)) { | 4760 if (info.Length() < 1) { |
4761 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4761 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4762 return; | 4762 return; |
4763 } | 4763 } |
4764 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4764 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4765 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 4765 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); |
4766 if (UNLIKELY(info.Length() <= 1)) { | 4766 if (UNLIKELY(info.Length() <= 1)) { |
4767 imp->overloadedMethodB(longArg1); | 4767 imp->overloadedMethodB(longArg1); |
4768 return; | 4768 return; |
4769 } | 4769 } |
4770 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 4770 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); |
(...skipping 22 matching lines...) Expand all Loading... |
4793 | 4793 |
4794 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4794 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4795 { | 4795 { |
4796 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4796 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4797 TestObjectPythonV8Internal::overloadedMethodBMethod(info); | 4797 TestObjectPythonV8Internal::overloadedMethodBMethod(info); |
4798 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4798 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4799 } | 4799 } |
4800 | 4800 |
4801 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4801 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4802 { | 4802 { |
4803 if (UNLIKELY(info.Length() < 1)) { | 4803 if (info.Length() < 1) { |
4804 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4804 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4805 return; | 4805 return; |
4806 } | 4806 } |
4807 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4807 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4808 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4808 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4809 imp->overloadedMethodC(longArg); | 4809 imp->overloadedMethodC(longArg); |
4810 } | 4810 } |
4811 | 4811 |
4812 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4812 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4813 { | 4813 { |
4814 if (UNLIKELY(info.Length() < 1)) { | 4814 if (info.Length() < 1) { |
4815 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4815 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4816 return; | 4816 return; |
4817 } | 4817 } |
4818 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4818 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4819 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4819 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4820 V8TRYCATCH_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1)); | 4820 V8TRYCATCH_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1)); |
4821 imp->overloadedMethodC(longArg, longArgs); | 4821 imp->overloadedMethodC(longArg, longArgs); |
4822 } | 4822 } |
4823 | 4823 |
4824 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4824 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
(...skipping 18 matching lines...) Expand all Loading... |
4843 | 4843 |
4844 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4844 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4845 { | 4845 { |
4846 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4846 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4847 TestObjectPythonV8Internal::overloadedMethodCMethod(info); | 4847 TestObjectPythonV8Internal::overloadedMethodCMethod(info); |
4848 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4848 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4849 } | 4849 } |
4850 | 4850 |
4851 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4851 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4852 { | 4852 { |
4853 if (UNLIKELY(info.Length() < 1)) { | 4853 if (info.Length() < 1) { |
4854 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4854 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4855 return; | 4855 return; |
4856 } | 4856 } |
4857 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4857 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4858 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4858 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4859 imp->overloadedMethodD(longArg); | 4859 imp->overloadedMethodD(longArg); |
4860 } | 4860 } |
4861 | 4861 |
4862 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4862 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4863 { | 4863 { |
4864 if (UNLIKELY(info.Length() < 1)) { | 4864 if (info.Length() < 1) { |
4865 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4865 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4866 return; | 4866 return; |
4867 } | 4867 } |
4868 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4868 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4869 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 4869 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
4870 imp->overloadedMethodD(testInterfaceEmptyArg); | 4870 imp->overloadedMethodD(testInterfaceEmptyArg); |
4871 } | 4871 } |
4872 | 4872 |
4873 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4873 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4874 { | 4874 { |
(...skipping 17 matching lines...) Expand all Loading... |
4892 | 4892 |
4893 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4893 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4894 { | 4894 { |
4895 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4895 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4896 TestObjectPythonV8Internal::overloadedMethodDMethod(info); | 4896 TestObjectPythonV8Internal::overloadedMethodDMethod(info); |
4897 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4897 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4898 } | 4898 } |
4899 | 4899 |
4900 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4900 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4901 { | 4901 { |
4902 if (UNLIKELY(info.Length() < 1)) { | 4902 if (info.Length() < 1) { |
4903 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4903 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4904 return; | 4904 return; |
4905 } | 4905 } |
4906 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4906 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4907 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4907 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4908 imp->overloadedMethodE(longArg); | 4908 imp->overloadedMethodE(longArg); |
4909 } | 4909 } |
4910 | 4910 |
4911 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4911 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4912 { | 4912 { |
4913 if (UNLIKELY(info.Length() < 1)) { | 4913 if (info.Length() < 1) { |
4914 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4914 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4915 return; | 4915 return; |
4916 } | 4916 } |
4917 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4917 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4918 V8TRYCATCH_VOID(Vector<int>, longArrayArg, toNativeArray<int>(info[0], 1, in
fo.GetIsolate())); | 4918 V8TRYCATCH_VOID(Vector<int>, longArrayArg, toNativeArray<int>(info[0], 1, in
fo.GetIsolate())); |
4919 imp->overloadedMethodE(longArrayArg); | 4919 imp->overloadedMethodE(longArrayArg); |
4920 } | 4920 } |
4921 | 4921 |
4922 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4922 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4923 { | 4923 { |
(...skipping 17 matching lines...) Expand all Loading... |
4941 | 4941 |
4942 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4942 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4943 { | 4943 { |
4944 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4944 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4945 TestObjectPythonV8Internal::overloadedMethodEMethod(info); | 4945 TestObjectPythonV8Internal::overloadedMethodEMethod(info); |
4946 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4946 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4947 } | 4947 } |
4948 | 4948 |
4949 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4949 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4950 { | 4950 { |
4951 if (UNLIKELY(info.Length() < 1)) { | 4951 if (info.Length() < 1) { |
4952 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4952 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4953 return; | 4953 return; |
4954 } | 4954 } |
4955 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4955 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4956 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4956 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
4957 imp->overloadedMethodF(longArg); | 4957 imp->overloadedMethodF(longArg); |
4958 } | 4958 } |
4959 | 4959 |
4960 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4960 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4961 { | 4961 { |
4962 if (UNLIKELY(info.Length() < 1)) { | 4962 if (info.Length() < 1) { |
4963 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4963 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4964 return; | 4964 return; |
4965 } | 4965 } |
4966 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4966 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4967 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyNullableArg, V8TestIn
terfaceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate(
))) ? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0)
; | 4967 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyNullableArg, V8TestIn
terfaceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate(
))) ? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0)
; |
4968 imp->overloadedMethodF(testInterfaceEmptyNullableArg); | 4968 imp->overloadedMethodF(testInterfaceEmptyNullableArg); |
4969 } | 4969 } |
4970 | 4970 |
4971 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4971 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4972 { | 4972 { |
(...skipping 23 matching lines...) Expand all Loading... |
4996 } | 4996 } |
4997 | 4997 |
4998 static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4998 static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4999 { | 4999 { |
5000 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5000 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5001 imp->overloadedMethodG(); | 5001 imp->overloadedMethodG(); |
5002 } | 5002 } |
5003 | 5003 |
5004 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5004 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
5005 { | 5005 { |
5006 if (UNLIKELY(info.Length() < 1)) { | 5006 if (info.Length() < 1) { |
5007 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodG", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5007 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodG", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
5008 return; | 5008 return; |
5009 } | 5009 } |
5010 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5010 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5011 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strictTypeCheckingS
tringArg, info[0]); | 5011 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strictTypeCheckingS
tringArg, info[0]); |
5012 imp->overloadedMethodG(strictTypeCheckingStringArg); | 5012 imp->overloadedMethodG(strictTypeCheckingStringArg); |
5013 } | 5013 } |
5014 | 5014 |
5015 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5015 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
5016 { | 5016 { |
(...skipping 22 matching lines...) Expand all Loading... |
5039 } | 5039 } |
5040 | 5040 |
5041 static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) | 5041 static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) |
5042 { | 5042 { |
5043 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5043 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5044 imp->overloadedPerWorldBindingsMethod(); | 5044 imp->overloadedPerWorldBindingsMethod(); |
5045 } | 5045 } |
5046 | 5046 |
5047 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 5047 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
5048 { | 5048 { |
5049 if (UNLIKELY(info.Length() < 1)) { | 5049 if (info.Length() < 1) { |
5050 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 5050 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); |
5051 return; | 5051 return; |
5052 } | 5052 } |
5053 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5053 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5054 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5054 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
5055 imp->overloadedPerWorldBindingsMethod(longArg); | 5055 imp->overloadedPerWorldBindingsMethod(longArg); |
5056 } | 5056 } |
5057 | 5057 |
5058 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) | 5058 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) |
5059 { | 5059 { |
(...skipping 10 matching lines...) Expand all Loading... |
5070 | 5070 |
5071 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 5071 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
5072 { | 5072 { |
5073 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5073 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5074 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethod(info); | 5074 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethod(info); |
5075 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5075 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5076 } | 5076 } |
5077 | 5077 |
5078 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) | 5078 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) |
5079 { | 5079 { |
5080 if (UNLIKELY(info.Length() < 1)) { | 5080 if (info.Length() < 1) { |
5081 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 5081 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); |
5082 return; | 5082 return; |
5083 } | 5083 } |
5084 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5084 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5085 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5085 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
5086 imp->overloadedPerWorldBindingsMethod(longArg); | 5086 imp->overloadedPerWorldBindingsMethod(longArg); |
5087 } | 5087 } |
5088 | 5088 |
5089 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio
nCallbackInfo<v8::Value>& info) | 5089 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio
nCallbackInfo<v8::Value>& info) |
5090 { | 5090 { |
(...skipping 10 matching lines...) Expand all Loading... |
5101 | 5101 |
5102 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8:
:FunctionCallbackInfo<v8::Value>& info) | 5102 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8:
:FunctionCallbackInfo<v8::Value>& info) |
5103 { | 5103 { |
5104 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5104 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5105 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodForMainWor
ld(info); | 5105 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodForMainWor
ld(info); |
5106 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5106 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5107 } | 5107 } |
5108 | 5108 |
5109 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 5109 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
5110 { | 5110 { |
5111 if (UNLIKELY(info.Length() < 1)) { | 5111 if (info.Length() < 1) { |
5112 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()))
, info.GetIsolate()); | 5112 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()))
, info.GetIsolate()); |
5113 return; | 5113 return; |
5114 } | 5114 } |
5115 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5115 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); |
5116 TestObjectPython::overloadedStaticMethod(longArg); | 5116 TestObjectPython::overloadedStaticMethod(longArg); |
5117 } | 5117 } |
5118 | 5118 |
5119 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 5119 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
5120 { | 5120 { |
5121 if (UNLIKELY(info.Length() < 2)) { | 5121 if (info.Length() < 2) { |
5122 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length()))
, info.GetIsolate()); | 5122 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length()))
, info.GetIsolate()); |
5123 return; | 5123 return; |
5124 } | 5124 } |
5125 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 5125 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); |
5126 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 5126 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); |
5127 TestObjectPython::overloadedStaticMethod(longArg1, longArg2); | 5127 TestObjectPython::overloadedStaticMethod(longArg1, longArg2); |
5128 } | 5128 } |
5129 | 5129 |
5130 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) | 5130 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) |
5131 { | 5131 { |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5205 | 5205 |
5206 static void removeEventListenerMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 5206 static void removeEventListenerMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
5207 { | 5207 { |
5208 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5208 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5209 TestObjectPythonV8Internal::removeEventListenerMethod(info); | 5209 TestObjectPythonV8Internal::removeEventListenerMethod(info); |
5210 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5210 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5211 } | 5211 } |
5212 | 5212 |
5213 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 5213 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
5214 { | 5214 { |
5215 if (UNLIKELY(info.Length() < 1)) { | 5215 if (info.Length() < 1) { |
5216 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edShortArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); | 5216 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edShortArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); |
5217 return; | 5217 return; |
5218 } | 5218 } |
5219 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5219 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5220 unsigned clampUnsignedShortArg = 0; | 5220 unsigned clampUnsignedShortArg = 0; |
5221 V8TRYCATCH_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberVal
ue()); | 5221 V8TRYCATCH_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberVal
ue()); |
5222 if (!std::isnan(clampUnsignedShortArgNativeValue)) | 5222 if (!std::isnan(clampUnsignedShortArgNativeValue)) |
5223 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNat
iveValue); | 5223 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNat
iveValue); |
5224 imp->voidMethodClampUnsignedShortArg(clampUnsignedShortArg); | 5224 imp->voidMethodClampUnsignedShortArg(clampUnsignedShortArg); |
5225 } | 5225 } |
5226 | 5226 |
5227 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 5227 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
5228 { | 5228 { |
5229 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5229 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5230 TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethod(info); | 5230 TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethod(info); |
5231 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5231 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5232 } | 5232 } |
5233 | 5233 |
5234 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) | 5234 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) |
5235 { | 5235 { |
5236 if (UNLIKELY(info.Length() < 1)) { | 5236 if (info.Length() < 1) { |
5237 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Le
ngth())), info.GetIsolate()); | 5237 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Le
ngth())), info.GetIsolate()); |
5238 return; | 5238 return; |
5239 } | 5239 } |
5240 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5240 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5241 unsigned clampUnsignedLongArg = 0; | 5241 unsigned clampUnsignedLongArg = 0; |
5242 V8TRYCATCH_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValu
e()); | 5242 V8TRYCATCH_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValu
e()); |
5243 if (!std::isnan(clampUnsignedLongArgNativeValue)) | 5243 if (!std::isnan(clampUnsignedLongArgNativeValue)) |
5244 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNative
Value); | 5244 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNative
Value); |
5245 imp->voidMethodClampUnsignedLongArg(clampUnsignedLongArg); | 5245 imp->voidMethodClampUnsignedLongArg(clampUnsignedLongArg); |
5246 } | 5246 } |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5303 | 5303 |
5304 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 5304 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
5305 { | 5305 { |
5306 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5306 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5307 TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethod(info)
; | 5307 TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethod(info)
; |
5308 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5308 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5309 } | 5309 } |
5310 | 5310 |
5311 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) | 5311 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) |
5312 { | 5312 { |
5313 if (UNLIKELY(info.Length() < 1)) { | 5313 if (info.Length() < 1) { |
5314 throwTypeError(ExceptionMessages::failedToExecute("voidMethodEnforceRang
eLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); | 5314 throwTypeError(ExceptionMessages::failedToExecute("voidMethodEnforceRang
eLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); |
5315 return; | 5315 return; |
5316 } | 5316 } |
5317 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5317 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5318 V8TRYCATCH_WITH_TYPECHECK_VOID(int, enforceRangeLongArg, toInt32(info[0], En
forceRange, ok), info.GetIsolate()); | 5318 V8TRYCATCH_WITH_TYPECHECK_VOID(int, enforceRangeLongArg, toInt32(info[0], En
forceRange, ok), info.GetIsolate()); |
5319 imp->voidMethodEnforceRangeLongArg(enforceRangeLongArg); | 5319 imp->voidMethodEnforceRangeLongArg(enforceRangeLongArg); |
5320 } | 5320 } |
5321 | 5321 |
5322 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 5322 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
5323 { | 5323 { |
5324 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5324 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5325 TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethod(info); | 5325 TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethod(info); |
5326 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5326 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5327 } | 5327 } |
5328 | 5328 |
5329 static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 5329 static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
5330 { | 5330 { |
5331 if (UNLIKELY(info.Length() < 1)) { | 5331 if (info.Length() < 1) { |
5332 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAs
NullStringStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(
1, info.Length())), info.GetIsolate()); | 5332 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAs
NullStringStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(
1, info.Length())), info.GetIsolate()); |
5333 return; | 5333 return; |
5334 } | 5334 } |
5335 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5335 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5336 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, treatN
ullAsNullStringStringArg, info[0]); | 5336 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, treatN
ullAsNullStringStringArg, info[0]); |
5337 imp->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg
); | 5337 imp->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg
); |
5338 } | 5338 } |
5339 | 5339 |
5340 static void voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::Fun
ctionCallbackInfo<v8::Value>& info) | 5340 static void voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::Fun
ctionCallbackInfo<v8::Value>& info) |
5341 { | 5341 { |
5342 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5342 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5343 TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(i
nfo); | 5343 TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(i
nfo); |
5344 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5344 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5345 } | 5345 } |
5346 | 5346 |
5347 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
thod(const v8::FunctionCallbackInfo<v8::Value>& info) | 5347 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
thod(const v8::FunctionCallbackInfo<v8::Value>& info) |
5348 { | 5348 { |
5349 if (UNLIKELY(info.Length() < 1)) { | 5349 if (info.Length() < 1) { |
5350 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAs
NullStringTreatUndefinedAsNullStringStringArg", "TestObjectPython", ExceptionMes
sages::notEnoughArguments(1, info.Length())), info.GetIsolate()); | 5350 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAs
NullStringTreatUndefinedAsNullStringStringArg", "TestObjectPython", ExceptionMes
sages::notEnoughArguments(1, info.Length())), info.GetIsolate()); |
5351 return; | 5351 return; |
5352 } | 5352 } |
5353 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5353 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5354 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullChe
ck>, treatNullAsNullStringStringArg, info[0]); | 5354 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullChe
ck>, treatNullAsNullStringStringArg, info[0]); |
5355 imp->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(trea
tNullAsNullStringStringArg); | 5355 imp->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(trea
tNullAsNullStringStringArg); |
5356 } | 5356 } |
5357 | 5357 |
5358 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) | 5358 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMe
thodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) |
5359 { | 5359 { |
(...skipping 461 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5821 | 5821 |
5822 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCall
backForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) | 5822 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCall
backForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) |
5823 { | 5823 { |
5824 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5824 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5825 TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindings
VoidMethodMethodForMainWorld(info); | 5825 TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindings
VoidMethodMethodForMainWorld(info); |
5826 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5826 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5827 } | 5827 } |
5828 | 5828 |
5829 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 5829 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
5830 { | 5830 { |
5831 if (UNLIKELY(info.Length() < 1)) { | 5831 if (info.Length() < 1) { |
5832 throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidM
ethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); | 5832 throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidM
ethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); |
5833 return; | 5833 return; |
5834 } | 5834 } |
5835 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5835 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5836 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 5836 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
5837 imp->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); | 5837 imp->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); |
5838 } | 5838 } |
5839 | 5839 |
5840 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 5840 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
5841 { | 5841 { |
5842 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5842 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5843 TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgM
ethod(info); | 5843 TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgM
ethod(info); |
5844 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5844 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5845 } | 5845 } |
5846 | 5846 |
5847 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) | 5847 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co
nst v8::FunctionCallbackInfo<v8::Value>& info) |
5848 { | 5848 { |
5849 if (UNLIKELY(info.Length() < 1)) { | 5849 if (info.Length() < 1) { |
5850 throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidM
ethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); | 5850 throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidM
ethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); |
5851 return; | 5851 return; |
5852 } | 5852 } |
5853 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5853 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5854 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 5854 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
5855 imp->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); | 5855 imp->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg); |
5856 } | 5856 } |
5857 | 5857 |
5858 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) | 5858 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMain
World(const v8::FunctionCallbackInfo<v8::Value>& info) |
5859 { | 5859 { |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5961 | 5961 |
5962 static void perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld(c
onst v8::FunctionCallbackInfo<v8::Value>& info) | 5962 static void perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld(c
onst v8::FunctionCallbackInfo<v8::Value>& info) |
5963 { | 5963 { |
5964 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5964 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5965 TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodFo
rMainWorld(info); | 5965 TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodFo
rMainWorld(info); |
5966 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5966 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5967 } | 5967 } |
5968 | 5968 |
5969 static void strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(const v8::Fu
nctionCallbackInfo<v8::Value>& info) | 5969 static void strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(const v8::Fu
nctionCallbackInfo<v8::Value>& info) |
5970 { | 5970 { |
5971 if (UNLIKELY(info.Length() < 1)) { | 5971 if (info.Length() < 1) { |
5972 throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoi
dMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughA
rguments(1, info.Length())), info.GetIsolate()); | 5972 throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoi
dMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughA
rguments(1, info.Length())), info.GetIsolate()); |
5973 return; | 5973 return; |
5974 } | 5974 } |
5975 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5975 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5976 if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpt
y::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))) { | 5976 if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpt
y::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))) { |
5977 throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoi
dMethodTestInterfaceEmptyArg", "TestObjectPython", "parameter 1 is not of type '
TestInterfaceEmpty'."), info.GetIsolate()); | 5977 throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoi
dMethodTestInterfaceEmptyArg", "TestObjectPython", "parameter 1 is not of type '
TestInterfaceEmpty'."), info.GetIsolate()); |
5978 return; | 5978 return; |
5979 } | 5979 } |
5980 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 5980 V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceE
mpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate())) ? V8
TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
5981 imp->strictTypeCheckingVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg
); | 5981 imp->strictTypeCheckingVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg
); |
(...skipping 570 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6552 fromInternalPointer(object)->deref(); | 6552 fromInternalPointer(object)->deref(); |
6553 } | 6553 } |
6554 | 6554 |
6555 template<> | 6555 template<> |
6556 v8::Handle<v8::Value> toV8NoInline(TestObjectPython* impl, v8::Handle<v8::Object
> creationContext, v8::Isolate* isolate) | 6556 v8::Handle<v8::Value> toV8NoInline(TestObjectPython* impl, v8::Handle<v8::Object
> creationContext, v8::Isolate* isolate) |
6557 { | 6557 { |
6558 return toV8(impl, creationContext, isolate); | 6558 return toV8(impl, creationContext, isolate); |
6559 } | 6559 } |
6560 | 6560 |
6561 } // namespace WebCore | 6561 } // namespace WebCore |
OLD | NEW |