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 247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
258 | 258 |
259 static void byteAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) | 259 static void byteAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) |
260 { | 260 { |
261 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 261 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
262 TestObjectPythonV8Internal::byteAttributeAttributeGetter(info); | 262 TestObjectPythonV8Internal::byteAttributeAttributeGetter(info); |
263 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 263 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
264 } | 264 } |
265 | 265 |
266 static void byteAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) | 266 static void byteAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) |
267 { | 267 { |
| 268 ExceptionState exceptionState(ExceptionState::SetterContext, "byteAttribute"
, "TestObjectPython", info.Holder(), info.GetIsolate()); |
268 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 269 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
269 V8TRYCATCH_VOID(int, cppValue, toInt8(jsValue)); | 270 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt8(jsValue, exceptionState), ex
ceptionState); |
270 imp->setByteAttribute(cppValue); | 271 imp->setByteAttribute(cppValue); |
271 } | 272 } |
272 | 273 |
273 static void byteAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 274 static void byteAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
274 { | 275 { |
275 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 276 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
276 TestObjectPythonV8Internal::byteAttributeAttributeSetter(jsValue, info); | 277 TestObjectPythonV8Internal::byteAttributeAttributeSetter(jsValue, info); |
277 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 278 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
278 } | 279 } |
279 | 280 |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 | 340 |
340 static void longAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) | 341 static void longAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8
::PropertyCallbackInfo<v8::Value>& info) |
341 { | 342 { |
342 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 343 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
343 TestObjectPythonV8Internal::longAttributeAttributeGetter(info); | 344 TestObjectPythonV8Internal::longAttributeAttributeGetter(info); |
344 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 345 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
345 } | 346 } |
346 | 347 |
347 static void longAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) | 348 static void longAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) |
348 { | 349 { |
| 350 ExceptionState exceptionState(ExceptionState::SetterContext, "longAttribute"
, "TestObjectPython", info.Holder(), info.GetIsolate()); |
349 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 351 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
350 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 352 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
351 imp->setLongAttribute(cppValue); | 353 imp->setLongAttribute(cppValue); |
352 } | 354 } |
353 | 355 |
354 static void longAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 356 static void longAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loca
l<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
355 { | 357 { |
356 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 358 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
357 TestObjectPythonV8Internal::longAttributeAttributeSetter(jsValue, info); | 359 TestObjectPythonV8Internal::longAttributeAttributeSetter(jsValue, info); |
358 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 360 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
359 } | 361 } |
360 | 362 |
361 static void longLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::
Value>& info) | 363 static void longLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::
Value>& info) |
362 { | 364 { |
363 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 365 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
364 v8SetReturnValue(info, static_cast<double>(imp->longLongAttribute())); | 366 v8SetReturnValue(info, static_cast<double>(imp->longLongAttribute())); |
365 } | 367 } |
366 | 368 |
367 static void longLongAttributeAttributeGetterCallback(v8::Local<v8::String>, cons
t v8::PropertyCallbackInfo<v8::Value>& info) | 369 static void longLongAttributeAttributeGetterCallback(v8::Local<v8::String>, cons
t v8::PropertyCallbackInfo<v8::Value>& info) |
368 { | 370 { |
369 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 371 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
370 TestObjectPythonV8Internal::longLongAttributeAttributeGetter(info); | 372 TestObjectPythonV8Internal::longLongAttributeAttributeGetter(info); |
371 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 373 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
372 } | 374 } |
373 | 375 |
374 static void longLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const
v8::PropertyCallbackInfo<void>& info) | 376 static void longLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const
v8::PropertyCallbackInfo<void>& info) |
375 { | 377 { |
| 378 ExceptionState exceptionState(ExceptionState::SetterContext, "longLongAttrib
ute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
376 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 379 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
377 V8TRYCATCH_VOID(long long, cppValue, toInt64(jsValue)); | 380 V8TRYCATCH_EXCEPTION_VOID(long long, cppValue, toInt64(jsValue, exceptionSta
te), exceptionState); |
378 imp->setLongLongAttribute(cppValue); | 381 imp->setLongLongAttribute(cppValue); |
379 } | 382 } |
380 | 383 |
381 static void longLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 384 static void longLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::
Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
382 { | 385 { |
383 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 386 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
384 TestObjectPythonV8Internal::longLongAttributeAttributeSetter(jsValue, info); | 387 TestObjectPythonV8Internal::longLongAttributeAttributeSetter(jsValue, info); |
385 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 388 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
386 } | 389 } |
387 | 390 |
388 static void octetAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Val
ue>& info) | 391 static void octetAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Val
ue>& info) |
389 { | 392 { |
390 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 393 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
391 v8SetReturnValueUnsigned(info, imp->octetAttribute()); | 394 v8SetReturnValueUnsigned(info, imp->octetAttribute()); |
392 } | 395 } |
393 | 396 |
394 static void octetAttributeAttributeGetterCallback(v8::Local<v8::String>, const v
8::PropertyCallbackInfo<v8::Value>& info) | 397 static void octetAttributeAttributeGetterCallback(v8::Local<v8::String>, const v
8::PropertyCallbackInfo<v8::Value>& info) |
395 { | 398 { |
396 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 399 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
397 TestObjectPythonV8Internal::octetAttributeAttributeGetter(info); | 400 TestObjectPythonV8Internal::octetAttributeAttributeGetter(info); |
398 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 401 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
399 } | 402 } |
400 | 403 |
401 static void octetAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8
::PropertyCallbackInfo<void>& info) | 404 static void octetAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8
::PropertyCallbackInfo<void>& info) |
402 { | 405 { |
| 406 ExceptionState exceptionState(ExceptionState::SetterContext, "octetAttribute
", "TestObjectPython", info.Holder(), info.GetIsolate()); |
403 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 407 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
404 V8TRYCATCH_VOID(unsigned, cppValue, toUInt8(jsValue)); | 408 V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt8(jsValue, exceptionStat
e), exceptionState); |
405 imp->setOctetAttribute(cppValue); | 409 imp->setOctetAttribute(cppValue); |
406 } | 410 } |
407 | 411 |
408 static void octetAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loc
al<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 412 static void octetAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loc
al<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
409 { | 413 { |
410 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 414 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
411 TestObjectPythonV8Internal::octetAttributeAttributeSetter(jsValue, info); | 415 TestObjectPythonV8Internal::octetAttributeAttributeSetter(jsValue, info); |
412 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 416 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
413 } | 417 } |
414 | 418 |
415 static void shortAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Val
ue>& info) | 419 static void shortAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Val
ue>& info) |
416 { | 420 { |
417 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 421 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
418 v8SetReturnValueInt(info, imp->shortAttribute()); | 422 v8SetReturnValueInt(info, imp->shortAttribute()); |
419 } | 423 } |
420 | 424 |
421 static void shortAttributeAttributeGetterCallback(v8::Local<v8::String>, const v
8::PropertyCallbackInfo<v8::Value>& info) | 425 static void shortAttributeAttributeGetterCallback(v8::Local<v8::String>, const v
8::PropertyCallbackInfo<v8::Value>& info) |
422 { | 426 { |
423 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 427 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
424 TestObjectPythonV8Internal::shortAttributeAttributeGetter(info); | 428 TestObjectPythonV8Internal::shortAttributeAttributeGetter(info); |
425 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 429 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
426 } | 430 } |
427 | 431 |
428 static void shortAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8
::PropertyCallbackInfo<void>& info) | 432 static void shortAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8
::PropertyCallbackInfo<void>& info) |
429 { | 433 { |
| 434 ExceptionState exceptionState(ExceptionState::SetterContext, "shortAttribute
", "TestObjectPython", info.Holder(), info.GetIsolate()); |
430 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 435 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
431 V8TRYCATCH_VOID(int, cppValue, toInt16(jsValue)); | 436 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt16(jsValue, exceptionState), e
xceptionState); |
432 imp->setShortAttribute(cppValue); | 437 imp->setShortAttribute(cppValue); |
433 } | 438 } |
434 | 439 |
435 static void shortAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loc
al<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 440 static void shortAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Loc
al<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
436 { | 441 { |
437 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 442 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
438 TestObjectPythonV8Internal::shortAttributeAttributeSetter(jsValue, info); | 443 TestObjectPythonV8Internal::shortAttributeAttributeSetter(jsValue, info); |
439 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 444 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
440 } | 445 } |
441 | 446 |
442 static void unsignedLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) | 447 static void unsignedLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<
v8::Value>& info) |
443 { | 448 { |
444 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 449 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
445 v8SetReturnValueUnsigned(info, imp->unsignedLongAttribute()); | 450 v8SetReturnValueUnsigned(info, imp->unsignedLongAttribute()); |
446 } | 451 } |
447 | 452 |
448 static void unsignedLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 453 static void unsignedLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
449 { | 454 { |
450 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 455 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
451 TestObjectPythonV8Internal::unsignedLongAttributeAttributeGetter(info); | 456 TestObjectPythonV8Internal::unsignedLongAttributeAttributeGetter(info); |
452 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 457 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
453 } | 458 } |
454 | 459 |
455 static void unsignedLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, c
onst v8::PropertyCallbackInfo<void>& info) | 460 static void unsignedLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, c
onst v8::PropertyCallbackInfo<void>& info) |
456 { | 461 { |
| 462 ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedLongAt
tribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
457 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 463 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
458 V8TRYCATCH_VOID(unsigned, cppValue, toUInt32(jsValue)); | 464 V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt32(jsValue, exceptionSta
te), exceptionState); |
459 imp->setUnsignedLongAttribute(cppValue); | 465 imp->setUnsignedLongAttribute(cppValue); |
460 } | 466 } |
461 | 467 |
462 static void unsignedLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 468 static void unsignedLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
463 { | 469 { |
464 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 470 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
465 TestObjectPythonV8Internal::unsignedLongAttributeAttributeSetter(jsValue, in
fo); | 471 TestObjectPythonV8Internal::unsignedLongAttributeAttributeSetter(jsValue, in
fo); |
466 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 472 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
467 } | 473 } |
468 | 474 |
469 static void unsignedLongLongAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) | 475 static void unsignedLongLongAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) |
470 { | 476 { |
471 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 477 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
472 v8SetReturnValue(info, static_cast<double>(imp->unsignedLongLongAttribute())
); | 478 v8SetReturnValue(info, static_cast<double>(imp->unsignedLongLongAttribute())
); |
473 } | 479 } |
474 | 480 |
475 static void unsignedLongLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) | 481 static void unsignedLongLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) |
476 { | 482 { |
477 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 483 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
478 TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeGetter(info); | 484 TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeGetter(info); |
479 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 485 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
480 } | 486 } |
481 | 487 |
482 static void unsignedLongLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) | 488 static void unsignedLongLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) |
483 { | 489 { |
| 490 ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedLongLo
ngAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
484 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 491 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
485 V8TRYCATCH_VOID(unsigned long long, cppValue, toUInt64(jsValue)); | 492 V8TRYCATCH_EXCEPTION_VOID(unsigned long long, cppValue, toUInt64(jsValue, ex
ceptionState), exceptionState); |
486 imp->setUnsignedLongLongAttribute(cppValue); | 493 imp->setUnsignedLongLongAttribute(cppValue); |
487 } | 494 } |
488 | 495 |
489 static void unsignedLongLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 496 static void unsignedLongLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
490 { | 497 { |
491 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 498 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
492 TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeSetter(jsValue
, info); | 499 TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeSetter(jsValue
, info); |
493 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 500 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
494 } | 501 } |
495 | 502 |
496 static void unsignedShortAttributeAttributeGetter(const v8::PropertyCallbackInfo
<v8::Value>& info) | 503 static void unsignedShortAttributeAttributeGetter(const v8::PropertyCallbackInfo
<v8::Value>& info) |
497 { | 504 { |
498 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 505 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
499 v8SetReturnValueUnsigned(info, imp->unsignedShortAttribute()); | 506 v8SetReturnValueUnsigned(info, imp->unsignedShortAttribute()); |
500 } | 507 } |
501 | 508 |
502 static void unsignedShortAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 509 static void unsignedShortAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
503 { | 510 { |
504 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 511 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
505 TestObjectPythonV8Internal::unsignedShortAttributeAttributeGetter(info); | 512 TestObjectPythonV8Internal::unsignedShortAttributeAttributeGetter(info); |
506 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 513 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
507 } | 514 } |
508 | 515 |
509 static void unsignedShortAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) | 516 static void unsignedShortAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) |
510 { | 517 { |
| 518 ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedShortA
ttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
511 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 519 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
512 V8TRYCATCH_VOID(unsigned, cppValue, toUInt16(jsValue)); | 520 V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt16(jsValue, exceptionSta
te), exceptionState); |
513 imp->setUnsignedShortAttribute(cppValue); | 521 imp->setUnsignedShortAttribute(cppValue); |
514 } | 522 } |
515 | 523 |
516 static void unsignedShortAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 524 static void unsignedShortAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
517 { | 525 { |
518 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 526 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
519 TestObjectPythonV8Internal::unsignedShortAttributeAttributeSetter(jsValue, i
nfo); | 527 TestObjectPythonV8Internal::unsignedShortAttributeAttributeSetter(jsValue, i
nfo); |
520 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 528 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
521 } | 529 } |
522 | 530 |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
609 | 617 |
610 static void cssAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) | 618 static void cssAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) |
611 { | 619 { |
612 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 620 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
613 TestObjectPythonV8Internal::cssAttributeAttributeGetter(info); | 621 TestObjectPythonV8Internal::cssAttributeAttributeGetter(info); |
614 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 622 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
615 } | 623 } |
616 | 624 |
617 static void cssAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) | 625 static void cssAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) |
618 { | 626 { |
| 627 ExceptionState exceptionState(ExceptionState::SetterContext, "cssAttribute",
"TestObjectPython", info.Holder(), info.GetIsolate()); |
619 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 628 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
620 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 629 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
621 imp->setCSSAttribute(cppValue); | 630 imp->setCSSAttribute(cppValue); |
622 } | 631 } |
623 | 632 |
624 static void cssAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 633 static void cssAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
625 { | 634 { |
626 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 635 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
627 TestObjectPythonV8Internal::cssAttributeAttributeSetter(jsValue, info); | 636 TestObjectPythonV8Internal::cssAttributeAttributeSetter(jsValue, info); |
628 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 637 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
629 } | 638 } |
630 | 639 |
631 static void imeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) | 640 static void imeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) |
632 { | 641 { |
633 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 642 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
634 v8SetReturnValueInt(info, imp->imeAttribute()); | 643 v8SetReturnValueInt(info, imp->imeAttribute()); |
635 } | 644 } |
636 | 645 |
637 static void imeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) | 646 static void imeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) |
638 { | 647 { |
639 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 648 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
640 TestObjectPythonV8Internal::imeAttributeAttributeGetter(info); | 649 TestObjectPythonV8Internal::imeAttributeAttributeGetter(info); |
641 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 650 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
642 } | 651 } |
643 | 652 |
644 static void imeAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) | 653 static void imeAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) |
645 { | 654 { |
| 655 ExceptionState exceptionState(ExceptionState::SetterContext, "imeAttribute",
"TestObjectPython", info.Holder(), info.GetIsolate()); |
646 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 656 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
647 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 657 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
648 imp->setIMEAttribute(cppValue); | 658 imp->setIMEAttribute(cppValue); |
649 } | 659 } |
650 | 660 |
651 static void imeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 661 static void imeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
652 { | 662 { |
653 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 663 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
654 TestObjectPythonV8Internal::imeAttributeAttributeSetter(jsValue, info); | 664 TestObjectPythonV8Internal::imeAttributeAttributeSetter(jsValue, info); |
655 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 665 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
656 } | 666 } |
657 | 667 |
658 static void svgAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) | 668 static void svgAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) |
659 { | 669 { |
660 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 670 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
661 v8SetReturnValueInt(info, imp->svgAttribute()); | 671 v8SetReturnValueInt(info, imp->svgAttribute()); |
662 } | 672 } |
663 | 673 |
664 static void svgAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) | 674 static void svgAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) |
665 { | 675 { |
666 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 676 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
667 TestObjectPythonV8Internal::svgAttributeAttributeGetter(info); | 677 TestObjectPythonV8Internal::svgAttributeAttributeGetter(info); |
668 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 678 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
669 } | 679 } |
670 | 680 |
671 static void svgAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) | 681 static void svgAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) |
672 { | 682 { |
| 683 ExceptionState exceptionState(ExceptionState::SetterContext, "svgAttribute",
"TestObjectPython", info.Holder(), info.GetIsolate()); |
673 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 684 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
674 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 685 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
675 imp->setSVGAttribute(cppValue); | 686 imp->setSVGAttribute(cppValue); |
676 } | 687 } |
677 | 688 |
678 static void svgAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 689 static void svgAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
679 { | 690 { |
680 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 691 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
681 TestObjectPythonV8Internal::svgAttributeAttributeSetter(jsValue, info); | 692 TestObjectPythonV8Internal::svgAttributeAttributeSetter(jsValue, info); |
682 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 693 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
683 } | 694 } |
684 | 695 |
685 static void xmlAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) | 696 static void xmlAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value
>& info) |
686 { | 697 { |
687 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 698 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
688 v8SetReturnValueInt(info, imp->xmlAttribute()); | 699 v8SetReturnValueInt(info, imp->xmlAttribute()); |
689 } | 700 } |
690 | 701 |
691 static void xmlAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) | 702 static void xmlAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8:
:PropertyCallbackInfo<v8::Value>& info) |
692 { | 703 { |
693 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 704 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
694 TestObjectPythonV8Internal::xmlAttributeAttributeGetter(info); | 705 TestObjectPythonV8Internal::xmlAttributeAttributeGetter(info); |
695 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 706 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
696 } | 707 } |
697 | 708 |
698 static void xmlAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) | 709 static void xmlAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::
PropertyCallbackInfo<void>& info) |
699 { | 710 { |
| 711 ExceptionState exceptionState(ExceptionState::SetterContext, "xmlAttribute",
"TestObjectPython", info.Holder(), info.GetIsolate()); |
700 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 712 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
701 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 713 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
702 imp->setXMLAttribute(cppValue); | 714 imp->setXMLAttribute(cppValue); |
703 } | 715 } |
704 | 716 |
705 static void xmlAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 717 static void xmlAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local
<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
706 { | 718 { |
707 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 719 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
708 TestObjectPythonV8Internal::xmlAttributeAttributeSetter(jsValue, info); | 720 TestObjectPythonV8Internal::xmlAttributeAttributeSetter(jsValue, info); |
709 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 721 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
710 } | 722 } |
711 | 723 |
(...skipping 597 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1309 | 1321 |
1310 static void nullableLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 1322 static void nullableLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
1311 { | 1323 { |
1312 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1324 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1313 TestObjectPythonV8Internal::nullableLongAttributeAttributeGetter(info); | 1325 TestObjectPythonV8Internal::nullableLongAttributeAttributeGetter(info); |
1314 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1326 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1315 } | 1327 } |
1316 | 1328 |
1317 static void nullableLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, c
onst v8::PropertyCallbackInfo<void>& info) | 1329 static void nullableLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, c
onst v8::PropertyCallbackInfo<void>& info) |
1318 { | 1330 { |
| 1331 ExceptionState exceptionState(ExceptionState::SetterContext, "nullableLongAt
tribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1319 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1332 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1320 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1333 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1321 imp->setNullableLongAttribute(cppValue); | 1334 imp->setNullableLongAttribute(cppValue); |
1322 } | 1335 } |
1323 | 1336 |
1324 static void nullableLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1337 static void nullableLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1325 { | 1338 { |
1326 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1339 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1327 TestObjectPythonV8Internal::nullableLongAttributeAttributeSetter(jsValue, in
fo); | 1340 TestObjectPythonV8Internal::nullableLongAttributeAttributeSetter(jsValue, in
fo); |
1328 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1341 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1329 } | 1342 } |
1330 | 1343 |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1390 | 1403 |
1391 static void staticLongAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 1404 static void staticLongAttributeAttributeGetterCallback(v8::Local<v8::String>, co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
1392 { | 1405 { |
1393 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1406 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1394 TestObjectPythonV8Internal::staticLongAttributeAttributeGetter(info); | 1407 TestObjectPythonV8Internal::staticLongAttributeAttributeGetter(info); |
1395 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1408 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1396 } | 1409 } |
1397 | 1410 |
1398 static void staticLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, con
st v8::PropertyCallbackInfo<void>& info) | 1411 static void staticLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, con
st v8::PropertyCallbackInfo<void>& info) |
1399 { | 1412 { |
1400 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1413 ExceptionState exceptionState(ExceptionState::SetterContext, "staticLongAttr
ibute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
| 1414 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1401 TestObjectPython::setStaticLongAttribute(cppValue); | 1415 TestObjectPython::setStaticLongAttribute(cppValue); |
1402 } | 1416 } |
1403 | 1417 |
1404 static void staticLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1418 static void staticLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1405 { | 1419 { |
1406 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1420 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1407 TestObjectPythonV8Internal::staticLongAttributeAttributeSetter(jsValue, info
); | 1421 TestObjectPythonV8Internal::staticLongAttributeAttributeSetter(jsValue, info
); |
1408 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1422 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1409 } | 1423 } |
1410 | 1424 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1447 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1461 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1448 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 1462 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
1449 if (contextData && contextData->activityLogger()) | 1463 if (contextData && contextData->activityLogger()) |
1450 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForAllWorldsLongAttribute", 0, 0, "Getter"); | 1464 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForAllWorldsLongAttribute", 0, 0, "Getter"); |
1451 TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAt
tributeGetter(info); | 1465 TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAt
tributeGetter(info); |
1452 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1466 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1453 } | 1467 } |
1454 | 1468 |
1455 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1469 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1456 { | 1470 { |
| 1471 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gAccessForAllWorldsLongAttribute", "TestObjectPython", info.Holder(), info.GetIs
olate()); |
1457 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1472 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1458 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1473 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1459 imp->setActivityLoggingAccessForAllWorldsLongAttribute(cppValue); | 1474 imp->setActivityLoggingAccessForAllWorldsLongAttribute(cppValue); |
1460 } | 1475 } |
1461 | 1476 |
1462 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) | 1477 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) |
1463 { | 1478 { |
1464 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1479 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1465 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 1480 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
1466 if (contextData && contextData->activityLogger()) { | 1481 if (contextData && contextData->activityLogger()) { |
1467 v8::Handle<v8::Value> loggerArg[] = { jsValue }; | 1482 v8::Handle<v8::Value> loggerArg[] = { jsValue }; |
1468 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter"); | 1483 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter"); |
(...skipping 13 matching lines...) Expand all Loading... |
1482 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1497 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1483 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 1498 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
1484 if (contextData && contextData->activityLogger()) | 1499 if (contextData && contextData->activityLogger()) |
1485 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erForAllWorldsLongAttribute", 0, 0, "Getter"); | 1500 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erForAllWorldsLongAttribute", 0, 0, "Getter"); |
1486 TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAt
tributeGetter(info); | 1501 TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAt
tributeGetter(info); |
1487 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1502 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1488 } | 1503 } |
1489 | 1504 |
1490 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1505 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1491 { | 1506 { |
| 1507 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gGetterForAllWorldsLongAttribute", "TestObjectPython", info.Holder(), info.GetIs
olate()); |
1492 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1508 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1493 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1509 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1494 imp->setActivityLoggingGetterForAllWorldsLongAttribute(cppValue); | 1510 imp->setActivityLoggingGetterForAllWorldsLongAttribute(cppValue); |
1495 } | 1511 } |
1496 | 1512 |
1497 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) | 1513 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) |
1498 { | 1514 { |
1499 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1515 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1500 TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAt
tributeSetter(jsValue, info); | 1516 TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAt
tributeSetter(jsValue, info); |
1501 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1517 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1502 } | 1518 } |
1503 | 1519 |
1504 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(const
v8::PropertyCallbackInfo<v8::Value>& info) | 1520 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(const
v8::PropertyCallbackInfo<v8::Value>& info) |
1505 { | 1521 { |
1506 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1522 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1507 v8SetReturnValueInt(info, imp->activityLoggingSetterForAllWorldsLongAttribut
e()); | 1523 v8SetReturnValueInt(info, imp->activityLoggingSetterForAllWorldsLongAttribut
e()); |
1508 } | 1524 } |
1509 | 1525 |
1510 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallbac
k(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1526 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallbac
k(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1511 { | 1527 { |
1512 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1528 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1513 TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAt
tributeGetter(info); | 1529 TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAt
tributeGetter(info); |
1514 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1530 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1515 } | 1531 } |
1516 | 1532 |
1517 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1533 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8::Lo
cal<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1518 { | 1534 { |
| 1535 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gSetterForAllWorldsLongAttribute", "TestObjectPython", info.Holder(), info.GetIs
olate()); |
1519 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1536 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1520 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1537 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1521 imp->setActivityLoggingSetterForAllWorldsLongAttribute(cppValue); | 1538 imp->setActivityLoggingSetterForAllWorldsLongAttribute(cppValue); |
1522 } | 1539 } |
1523 | 1540 |
1524 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) | 1541 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallbac
k(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbac
kInfo<void>& info) |
1525 { | 1542 { |
1526 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1543 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1527 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 1544 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
1528 if (contextData && contextData->activityLogger()) { | 1545 if (contextData && contextData->activityLogger()) { |
1529 v8::Handle<v8::Value> loggerArg[] = { jsValue }; | 1546 v8::Handle<v8::Value> loggerArg[] = { jsValue }; |
1530 contextData->activityLogger()->log("TestObjectPython.activityLoggingSett
erForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter"); | 1547 contextData->activityLogger()->log("TestObjectPython.activityLoggingSett
erForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter"); |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1632 { | 1649 { |
1633 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1650 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1634 TestObjectPythonV8Internal::conditionalLongAttributeAttributeGetter(info); | 1651 TestObjectPythonV8Internal::conditionalLongAttributeAttributeGetter(info); |
1635 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1652 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1636 } | 1653 } |
1637 #endif // ENABLE(CONDITION) | 1654 #endif // ENABLE(CONDITION) |
1638 | 1655 |
1639 #if ENABLE(CONDITION) | 1656 #if ENABLE(CONDITION) |
1640 static void conditionalLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue
, const v8::PropertyCallbackInfo<void>& info) | 1657 static void conditionalLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue
, const v8::PropertyCallbackInfo<void>& info) |
1641 { | 1658 { |
| 1659 ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalLon
gAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1642 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1660 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1643 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1661 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1644 imp->setConditionalLongAttribute(cppValue); | 1662 imp->setConditionalLongAttribute(cppValue); |
1645 } | 1663 } |
1646 #endif // ENABLE(CONDITION) | 1664 #endif // ENABLE(CONDITION) |
1647 | 1665 |
1648 #if ENABLE(CONDITION) | 1666 #if ENABLE(CONDITION) |
1649 static void conditionalLongAttributeAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1667 static void conditionalLongAttributeAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1650 { | 1668 { |
1651 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1669 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1652 TestObjectPythonV8Internal::conditionalLongAttributeAttributeSetter(jsValue,
info); | 1670 TestObjectPythonV8Internal::conditionalLongAttributeAttributeSetter(jsValue,
info); |
1653 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1671 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 13 matching lines...) Expand all Loading... |
1667 { | 1685 { |
1668 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1686 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1669 TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeGetter(info)
; | 1687 TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeGetter(info)
; |
1670 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1688 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1671 } | 1689 } |
1672 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2) | 1690 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2) |
1673 | 1691 |
1674 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2) | 1692 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2) |
1675 static void conditionalAndLongAttributeAttributeSetter(v8::Local<v8::Value> jsVa
lue, const v8::PropertyCallbackInfo<void>& info) | 1693 static void conditionalAndLongAttributeAttributeSetter(v8::Local<v8::Value> jsVa
lue, const v8::PropertyCallbackInfo<void>& info) |
1676 { | 1694 { |
| 1695 ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalAnd
LongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1677 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1696 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1678 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1697 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1679 imp->setConditionalAndLongAttribute(cppValue); | 1698 imp->setConditionalAndLongAttribute(cppValue); |
1680 } | 1699 } |
1681 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2) | 1700 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2) |
1682 | 1701 |
1683 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2) | 1702 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2) |
1684 static void conditionalAndLongAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1703 static void conditionalAndLongAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1685 { | 1704 { |
1686 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1705 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1687 TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeSetter(jsVal
ue, info); | 1706 TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeSetter(jsVal
ue, info); |
1688 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1707 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 13 matching lines...) Expand all Loading... |
1702 { | 1721 { |
1703 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1722 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1704 TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeGetter(info); | 1723 TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeGetter(info); |
1705 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1724 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1706 } | 1725 } |
1707 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2) | 1726 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2) |
1708 | 1727 |
1709 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2) | 1728 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2) |
1710 static void conditionalOrLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) | 1729 static void conditionalOrLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) |
1711 { | 1730 { |
| 1731 ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalOrL
ongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1712 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1732 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1713 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1733 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1714 imp->setConditionalOrLongAttribute(cppValue); | 1734 imp->setConditionalOrLongAttribute(cppValue); |
1715 } | 1735 } |
1716 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2) | 1736 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2) |
1717 | 1737 |
1718 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2) | 1738 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2) |
1719 static void conditionalOrLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1739 static void conditionalOrLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1720 { | 1740 { |
1721 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1741 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1722 TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeSetter(jsValu
e, info); | 1742 TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeSetter(jsValu
e, info); |
1723 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1743 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 16 matching lines...) Expand all Loading... |
1740 | 1760 |
1741 static void customGetterLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1761 static void customGetterLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1742 { | 1762 { |
1743 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1763 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1744 V8TestObjectPython::customGetterLongAttributeAttributeGetterCustom(info); | 1764 V8TestObjectPython::customGetterLongAttributeAttributeGetterCustom(info); |
1745 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1765 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1746 } | 1766 } |
1747 | 1767 |
1748 static void customGetterLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) | 1768 static void customGetterLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) |
1749 { | 1769 { |
| 1770 ExceptionState exceptionState(ExceptionState::SetterContext, "customGetterLo
ngAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1750 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1771 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1751 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1772 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1752 imp->setCustomGetterLongAttribute(cppValue); | 1773 imp->setCustomGetterLongAttribute(cppValue); |
1753 } | 1774 } |
1754 | 1775 |
1755 static void customGetterLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1776 static void customGetterLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1756 { | 1777 { |
1757 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1778 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1758 TestObjectPythonV8Internal::customGetterLongAttributeAttributeSetter(jsValue
, info); | 1779 TestObjectPythonV8Internal::customGetterLongAttributeAttributeSetter(jsValue
, info); |
1759 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1780 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1760 } | 1781 } |
1761 | 1782 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1826 static void deprecatedLongAttributeAttributeGetterCallback(v8::Local<v8::String>
, const v8::PropertyCallbackInfo<v8::Value>& info) | 1847 static void deprecatedLongAttributeAttributeGetterCallback(v8::Local<v8::String>
, const v8::PropertyCallbackInfo<v8::Value>& info) |
1827 { | 1848 { |
1828 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1849 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1829 UseCounter::countDeprecation(activeExecutionContext(), UseCounter::LongAttri
bute); | 1850 UseCounter::countDeprecation(activeExecutionContext(), UseCounter::LongAttri
bute); |
1830 TestObjectPythonV8Internal::deprecatedLongAttributeAttributeGetter(info); | 1851 TestObjectPythonV8Internal::deprecatedLongAttributeAttributeGetter(info); |
1831 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1852 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1832 } | 1853 } |
1833 | 1854 |
1834 static void deprecatedLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) | 1855 static void deprecatedLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) |
1835 { | 1856 { |
| 1857 ExceptionState exceptionState(ExceptionState::SetterContext, "deprecatedLong
Attribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1836 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1858 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1837 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1859 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1838 imp->setDeprecatedLongAttribute(cppValue); | 1860 imp->setDeprecatedLongAttribute(cppValue); |
1839 } | 1861 } |
1840 | 1862 |
1841 static void deprecatedLongAttributeAttributeSetterCallback(v8::Local<v8::String>
, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1863 static void deprecatedLongAttributeAttributeSetterCallback(v8::Local<v8::String>
, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1842 { | 1864 { |
1843 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1865 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1844 UseCounter::countDeprecation(activeExecutionContext(), UseCounter::LongAttri
bute); | 1866 UseCounter::countDeprecation(activeExecutionContext(), UseCounter::LongAttri
bute); |
1845 TestObjectPythonV8Internal::deprecatedLongAttributeAttributeSetter(jsValue,
info); | 1867 TestObjectPythonV8Internal::deprecatedLongAttributeAttributeSetter(jsValue,
info); |
1846 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1868 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1847 } | 1869 } |
1848 | 1870 |
1849 static void enforceRangeLongAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) | 1871 static void enforceRangeLongAttributeAttributeGetter(const v8::PropertyCallbackI
nfo<v8::Value>& info) |
1850 { | 1872 { |
1851 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1873 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1852 v8SetReturnValueInt(info, imp->enforceRangeLongAttribute()); | 1874 v8SetReturnValueInt(info, imp->enforceRangeLongAttribute()); |
1853 } | 1875 } |
1854 | 1876 |
1855 static void enforceRangeLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1877 static void enforceRangeLongAttributeAttributeGetterCallback(v8::Local<v8::Strin
g>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1856 { | 1878 { |
1857 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1879 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1858 TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeGetter(info); | 1880 TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeGetter(info); |
1859 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1881 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1860 } | 1882 } |
1861 | 1883 |
1862 static void enforceRangeLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) | 1884 static void enforceRangeLongAttributeAttributeSetter(v8::Local<v8::Value> jsValu
e, const v8::PropertyCallbackInfo<void>& info) |
1863 { | 1885 { |
| 1886 ExceptionState exceptionState(ExceptionState::SetterContext, "enforceRangeLo
ngAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1864 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1887 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1865 V8TRYCATCH_WITH_TYPECHECK_VOID(int, cppValue, toInt32(jsValue, EnforceRange,
ok), info.GetIsolate()); | 1888 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, EnforceRange, exce
ptionState), exceptionState); |
1866 imp->setEnforceRangeLongAttribute(cppValue); | 1889 imp->setEnforceRangeLongAttribute(cppValue); |
1867 } | 1890 } |
1868 | 1891 |
1869 static void enforceRangeLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1892 static void enforceRangeLongAttributeAttributeSetterCallback(v8::Local<v8::Strin
g>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1870 { | 1893 { |
1871 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1894 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1872 TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeSetter(jsValue
, info); | 1895 TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeSetter(jsValue
, info); |
1873 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1896 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1874 } | 1897 } |
1875 | 1898 |
1876 static void exposeJSAccessorsLongAttributeAttributeGetter(const v8::FunctionCall
backInfo<v8::Value>& info) | 1899 static void exposeJSAccessorsLongAttributeAttributeGetter(const v8::FunctionCall
backInfo<v8::Value>& info) |
1877 { | 1900 { |
1878 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1901 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1879 v8SetReturnValueInt(info, imp->exposeJSAccessorsLongAttribute()); | 1902 v8SetReturnValueInt(info, imp->exposeJSAccessorsLongAttribute()); |
1880 } | 1903 } |
1881 | 1904 |
1882 static void exposeJSAccessorsLongAttributeAttributeGetterCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 1905 static void exposeJSAccessorsLongAttributeAttributeGetterCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
1883 { | 1906 { |
1884 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1907 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1885 TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeGetter(in
fo); | 1908 TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeGetter(in
fo); |
1886 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1909 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1887 } | 1910 } |
1888 | 1911 |
1889 static void exposeJSAccessorsLongAttributeAttributeSetter(v8::Local<v8::Value> j
sValue, const v8::FunctionCallbackInfo<v8::Value>& info) | 1912 static void exposeJSAccessorsLongAttributeAttributeSetter(v8::Local<v8::Value> j
sValue, const v8::FunctionCallbackInfo<v8::Value>& info) |
1890 { | 1913 { |
| 1914 ExceptionState exceptionState(ExceptionState::SetterContext, "exposeJSAccess
orsLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1891 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1915 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1892 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1916 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1893 imp->setExposeJSAccessorsLongAttribute(cppValue); | 1917 imp->setExposeJSAccessorsLongAttribute(cppValue); |
1894 } | 1918 } |
1895 | 1919 |
1896 static void exposeJSAccessorsLongAttributeAttributeSetterCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 1920 static void exposeJSAccessorsLongAttributeAttributeSetterCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
1897 { | 1921 { |
1898 v8::Local<v8::Value> jsValue = info[0]; | 1922 v8::Local<v8::Value> jsValue = info[0]; |
1899 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1923 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1900 TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeSetter(js
Value, info); | 1924 TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeSetter(js
Value, info); |
1901 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1925 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1902 } | 1926 } |
(...skipping 10 matching lines...) Expand all Loading... |
1913 | 1937 |
1914 static void getterRaisesExceptionLongAttributeAttributeGetterCallback(v8::Local<
v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1938 static void getterRaisesExceptionLongAttributeAttributeGetterCallback(v8::Local<
v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1915 { | 1939 { |
1916 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1940 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1917 TestObjectPythonV8Internal::getterRaisesExceptionLongAttributeAttributeGette
r(info); | 1941 TestObjectPythonV8Internal::getterRaisesExceptionLongAttributeAttributeGette
r(info); |
1918 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1942 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1919 } | 1943 } |
1920 | 1944 |
1921 static void getterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Valu
e> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1945 static void getterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Valu
e> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1922 { | 1946 { |
| 1947 ExceptionState exceptionState(ExceptionState::SetterContext, "getterRaisesEx
ceptionLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1923 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1948 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1924 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1949 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1925 imp->setGetterRaisesExceptionLongAttribute(cppValue); | 1950 imp->setGetterRaisesExceptionLongAttribute(cppValue); |
1926 } | 1951 } |
1927 | 1952 |
1928 static void getterRaisesExceptionLongAttributeAttributeSetterCallback(v8::Local<
v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>&
info) | 1953 static void getterRaisesExceptionLongAttributeAttributeSetterCallback(v8::Local<
v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>&
info) |
1929 { | 1954 { |
1930 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1955 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1931 TestObjectPythonV8Internal::getterRaisesExceptionLongAttributeAttributeSette
r(jsValue, info); | 1956 TestObjectPythonV8Internal::getterRaisesExceptionLongAttributeAttributeSette
r(jsValue, info); |
1932 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1957 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1933 } | 1958 } |
1934 | 1959 |
1935 static void implementedAsLongAttributeAttributeGetter(const v8::PropertyCallback
Info<v8::Value>& info) | 1960 static void implementedAsLongAttributeAttributeGetter(const v8::PropertyCallback
Info<v8::Value>& info) |
1936 { | 1961 { |
1937 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1962 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1938 v8SetReturnValueInt(info, imp->implementedAsName()); | 1963 v8SetReturnValueInt(info, imp->implementedAsName()); |
1939 } | 1964 } |
1940 | 1965 |
1941 static void implementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::Stri
ng>, const v8::PropertyCallbackInfo<v8::Value>& info) | 1966 static void implementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::Stri
ng>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1942 { | 1967 { |
1943 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 1968 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1944 TestObjectPythonV8Internal::implementedAsLongAttributeAttributeGetter(info); | 1969 TestObjectPythonV8Internal::implementedAsLongAttributeAttributeGetter(info); |
1945 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1970 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1946 } | 1971 } |
1947 | 1972 |
1948 static void implementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) | 1973 static void implementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) |
1949 { | 1974 { |
| 1975 ExceptionState exceptionState(ExceptionState::SetterContext, "implementedAsL
ongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
1950 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 1976 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1951 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 1977 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1952 imp->setImplementedAsName(cppValue); | 1978 imp->setImplementedAsName(cppValue); |
1953 } | 1979 } |
1954 | 1980 |
1955 static void implementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 1981 static void implementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1956 { | 1982 { |
1957 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 1983 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1958 TestObjectPythonV8Internal::implementedAsLongAttributeAttributeSetter(jsValu
e, info); | 1984 TestObjectPythonV8Internal::implementedAsLongAttributeAttributeSetter(jsValu
e, info); |
1959 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 1985 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1960 } | 1986 } |
1961 | 1987 |
(...skipping 13 matching lines...) Expand all Loading... |
1975 | 2001 |
1976 static void customGetterImplementedAsLongAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2002 static void customGetterImplementedAsLongAttributeAttributeGetterCallback(v8::Lo
cal<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
1977 { | 2003 { |
1978 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2004 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
1979 V8TestObjectPython::customGetterImplementedAsLongAttributeAttributeGetterCus
tom(info); | 2005 V8TestObjectPython::customGetterImplementedAsLongAttributeAttributeGetterCus
tom(info); |
1980 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2006 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1981 } | 2007 } |
1982 | 2008 |
1983 static void customGetterImplementedAsLongAttributeAttributeSetter(v8::Local<v8::
Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2009 static void customGetterImplementedAsLongAttributeAttributeSetter(v8::Local<v8::
Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
1984 { | 2010 { |
| 2011 ExceptionState exceptionState(ExceptionState::SetterContext, "customGetterIm
plementedAsLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate())
; |
1985 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2012 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
1986 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2013 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
1987 imp->setImplementedAsNameWithCustomGetter(cppValue); | 2014 imp->setImplementedAsNameWithCustomGetter(cppValue); |
1988 } | 2015 } |
1989 | 2016 |
1990 static void customGetterImplementedAsLongAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<vo
id>& info) | 2017 static void customGetterImplementedAsLongAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<vo
id>& info) |
1991 { | 2018 { |
1992 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2019 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
1993 TestObjectPythonV8Internal::customGetterImplementedAsLongAttributeAttributeS
etter(jsValue, info); | 2020 TestObjectPythonV8Internal::customGetterImplementedAsLongAttributeAttributeS
etter(jsValue, info); |
1994 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2021 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
1995 } | 2022 } |
1996 | 2023 |
(...skipping 26 matching lines...) Expand all Loading... |
2023 static void measureAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) | 2050 static void measureAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>,
const v8::PropertyCallbackInfo<v8::Value>& info) |
2024 { | 2051 { |
2025 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2052 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2026 UseCounter::count(activeExecutionContext(), UseCounter::TestFeature); | 2053 UseCounter::count(activeExecutionContext(), UseCounter::TestFeature); |
2027 TestObjectPythonV8Internal::measureAsLongAttributeAttributeGetter(info); | 2054 TestObjectPythonV8Internal::measureAsLongAttributeAttributeGetter(info); |
2028 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2055 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2029 } | 2056 } |
2030 | 2057 |
2031 static void measureAsLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) | 2058 static void measureAsLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue,
const v8::PropertyCallbackInfo<void>& info) |
2032 { | 2059 { |
| 2060 ExceptionState exceptionState(ExceptionState::SetterContext, "measureAsLongA
ttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2033 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2061 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2034 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2062 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2035 imp->setMeasureAsLongAttribute(cppValue); | 2063 imp->setMeasureAsLongAttribute(cppValue); |
2036 } | 2064 } |
2037 | 2065 |
2038 static void measureAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2066 static void measureAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>,
v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2039 { | 2067 { |
2040 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2068 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2041 UseCounter::count(activeExecutionContext(), UseCounter::TestFeature); | 2069 UseCounter::count(activeExecutionContext(), UseCounter::TestFeature); |
2042 TestObjectPythonV8Internal::measureAsLongAttributeAttributeSetter(jsValue, i
nfo); | 2070 TestObjectPythonV8Internal::measureAsLongAttributeAttributeSetter(jsValue, i
nfo); |
2043 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2071 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2044 } | 2072 } |
2045 | 2073 |
2046 static void notEnumerableLongAttributeAttributeGetter(const v8::PropertyCallback
Info<v8::Value>& info) | 2074 static void notEnumerableLongAttributeAttributeGetter(const v8::PropertyCallback
Info<v8::Value>& info) |
2047 { | 2075 { |
2048 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2076 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2049 v8SetReturnValueInt(info, imp->notEnumerableLongAttribute()); | 2077 v8SetReturnValueInt(info, imp->notEnumerableLongAttribute()); |
2050 } | 2078 } |
2051 | 2079 |
2052 static void notEnumerableLongAttributeAttributeGetterCallback(v8::Local<v8::Stri
ng>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2080 static void notEnumerableLongAttributeAttributeGetterCallback(v8::Local<v8::Stri
ng>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2053 { | 2081 { |
2054 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2082 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2055 TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeGetter(info); | 2083 TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeGetter(info); |
2056 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2084 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2057 } | 2085 } |
2058 | 2086 |
2059 static void notEnumerableLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) | 2087 static void notEnumerableLongAttributeAttributeSetter(v8::Local<v8::Value> jsVal
ue, const v8::PropertyCallbackInfo<void>& info) |
2060 { | 2088 { |
| 2089 ExceptionState exceptionState(ExceptionState::SetterContext, "notEnumerableL
ongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2061 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2090 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2062 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2091 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2063 imp->setNotEnumerableLongAttribute(cppValue); | 2092 imp->setNotEnumerableLongAttribute(cppValue); |
2064 } | 2093 } |
2065 | 2094 |
2066 static void notEnumerableLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2095 static void notEnumerableLongAttributeAttributeSetterCallback(v8::Local<v8::Stri
ng>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2067 { | 2096 { |
2068 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2097 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2069 TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeSetter(jsValu
e, info); | 2098 TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeSetter(jsValu
e, info); |
2070 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2099 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2071 } | 2100 } |
2072 | 2101 |
2073 static void perContextEnabledLongAttributeAttributeGetter(const v8::PropertyCall
backInfo<v8::Value>& info) | 2102 static void perContextEnabledLongAttributeAttributeGetter(const v8::PropertyCall
backInfo<v8::Value>& info) |
2074 { | 2103 { |
2075 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2104 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2076 v8SetReturnValueInt(info, imp->perContextEnabledLongAttribute()); | 2105 v8SetReturnValueInt(info, imp->perContextEnabledLongAttribute()); |
2077 } | 2106 } |
2078 | 2107 |
2079 static void perContextEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::
String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2108 static void perContextEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::
String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2080 { | 2109 { |
2081 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2110 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2082 TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeGetter(in
fo); | 2111 TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeGetter(in
fo); |
2083 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2112 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2084 } | 2113 } |
2085 | 2114 |
2086 static void perContextEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) | 2115 static void perContextEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) |
2087 { | 2116 { |
| 2117 ExceptionState exceptionState(ExceptionState::SetterContext, "perContextEnab
ledLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2088 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2118 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2089 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2119 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2090 imp->setPerContextEnabledLongAttribute(cppValue); | 2120 imp->setPerContextEnabledLongAttribute(cppValue); |
2091 } | 2121 } |
2092 | 2122 |
2093 static void perContextEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& inf
o) | 2123 static void perContextEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::
String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& inf
o) |
2094 { | 2124 { |
2095 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2125 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2096 TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeSetter(js
Value, info); | 2126 TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeSetter(js
Value, info); |
2097 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2127 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2098 } | 2128 } |
2099 | 2129 |
2100 static void perWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) | 2130 static void perWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) |
2101 { | 2131 { |
2102 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2132 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2103 v8SetReturnValueInt(info, imp->perWorldBindingsLongAttribute()); | 2133 v8SetReturnValueInt(info, imp->perWorldBindingsLongAttribute()); |
2104 } | 2134 } |
2105 | 2135 |
2106 static void perWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2136 static void perWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2107 { | 2137 { |
2108 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2138 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2109 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetter(inf
o); | 2139 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetter(inf
o); |
2110 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2140 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2111 } | 2141 } |
2112 | 2142 |
2113 static void perWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> js
Value, const v8::PropertyCallbackInfo<void>& info) | 2143 static void perWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> js
Value, const v8::PropertyCallbackInfo<void>& info) |
2114 { | 2144 { |
| 2145 ExceptionState exceptionState(ExceptionState::SetterContext, "perWorldBindin
gsLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2115 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2146 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2116 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2147 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2117 imp->setPerWorldBindingsLongAttribute(cppValue); | 2148 imp->setPerWorldBindingsLongAttribute(cppValue); |
2118 } | 2149 } |
2119 | 2150 |
2120 static void perWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info
) | 2151 static void perWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info
) |
2121 { | 2152 { |
2122 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2153 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2123 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetter(jsV
alue, info); | 2154 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetter(jsV
alue, info); |
2124 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2155 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2125 } | 2156 } |
2126 | 2157 |
2127 static void perWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::P
ropertyCallbackInfo<v8::Value>& info) | 2158 static void perWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::P
ropertyCallbackInfo<v8::Value>& info) |
2128 { | 2159 { |
2129 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2160 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2130 v8SetReturnValueInt(info, imp->perWorldBindingsLongAttribute()); | 2161 v8SetReturnValueInt(info, imp->perWorldBindingsLongAttribute()); |
2131 } | 2162 } |
2132 | 2163 |
2133 static void perWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8:
:Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2164 static void perWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8:
:Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2134 { | 2165 { |
2135 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2166 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2136 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetterForM
ainWorld(info); | 2167 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetterForM
ainWorld(info); |
2137 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2168 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2138 } | 2169 } |
2139 | 2170 |
2140 static void perWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v
8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2171 static void perWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v
8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2141 { | 2172 { |
| 2173 ExceptionState exceptionState(ExceptionState::SetterContext, "perWorldBindin
gsLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2142 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2174 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2143 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2175 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2144 imp->setPerWorldBindingsLongAttribute(cppValue); | 2176 imp->setPerWorldBindingsLongAttribute(cppValue); |
2145 } | 2177 } |
2146 | 2178 |
2147 static void perWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8:
:Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo
<void>& info) | 2179 static void perWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8:
:Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo
<void>& info) |
2148 { | 2180 { |
2149 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2181 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2150 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetterForM
ainWorld(jsValue, info); | 2182 TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetterForM
ainWorld(jsValue, info); |
2151 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2183 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2152 } | 2184 } |
2153 | 2185 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2188 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2220 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2189 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2221 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2190 if (contextData && contextData->activityLogger()) | 2222 if (contextData && contextData->activityLogger()) |
2191 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2223 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2192 TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttribu
teAttributeGetter(info); | 2224 TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttribu
teAttributeGetter(info); |
2193 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2225 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2194 } | 2226 } |
2195 | 2227 |
2196 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2228 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2197 { | 2229 { |
| 2230 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gAccessPerWorldBindingsLongAttribute", "TestObjectPython", info.Holder(), info.G
etIsolate()); |
2198 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2231 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2199 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2232 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2200 imp->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue); | 2233 imp->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue); |
2201 } | 2234 } |
2202 | 2235 |
2203 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCal
lbackInfo<void>& info) | 2236 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCal
lbackInfo<void>& info) |
2204 { | 2237 { |
2205 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2238 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2206 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2239 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2207 if (contextData && contextData->activityLogger()) { | 2240 if (contextData && contextData->activityLogger()) { |
2208 v8::Handle<v8::Value> loggerArg[] = { jsValue }; | 2241 v8::Handle<v8::Value> loggerArg[] = { jsValue }; |
2209 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); | 2242 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); |
(...skipping 13 matching lines...) Expand all Loading... |
2223 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2256 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2224 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2257 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2225 if (contextData && contextData->activityLogger()) | 2258 if (contextData && contextData->activityLogger()) |
2226 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2259 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2227 TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttribu
teAttributeGetterForMainWorld(info); | 2260 TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttribu
teAttributeGetterForMainWorld(info); |
2228 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2261 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2229 } | 2262 } |
2230 | 2263 |
2231 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterFor
MainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& in
fo) | 2264 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterFor
MainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& in
fo) |
2232 { | 2265 { |
| 2266 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gAccessPerWorldBindingsLongAttribute", "TestObjectPython", info.Holder(), info.G
etIsolate()); |
2233 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2267 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2234 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2268 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2235 imp->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue); | 2269 imp->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue); |
2236 } | 2270 } |
2237 | 2271 |
2238 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCal
lbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) | 2272 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCal
lbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) |
2239 { | 2273 { |
2240 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2274 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2241 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2275 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2242 if (contextData && contextData->activityLogger()) { | 2276 if (contextData && contextData->activityLogger()) { |
2243 v8::Handle<v8::Value> loggerArg[] = { jsValue }; | 2277 v8::Handle<v8::Value> loggerArg[] = { jsValue }; |
2244 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); | 2278 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); |
(...skipping 13 matching lines...) Expand all Loading... |
2258 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2292 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2259 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2293 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2260 if (contextData && contextData->activityLogger()) | 2294 if (contextData && contextData->activityLogger()) |
2261 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2295 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2262 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetter(info); | 2296 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetter(info); |
2263 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2297 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2264 } | 2298 } |
2265 | 2299 |
2266 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void
>& info) | 2300 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void
>& info) |
2267 { | 2301 { |
| 2302 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gAccessForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", info
.Holder(), info.GetIsolate()); |
2268 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2303 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2269 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2304 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2270 imp->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); | 2305 imp->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); |
2271 } | 2306 } |
2272 | 2307 |
2273 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, cons
t v8::PropertyCallbackInfo<void>& info) | 2308 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, cons
t v8::PropertyCallbackInfo<void>& info) |
2274 { | 2309 { |
2275 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2310 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2276 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2311 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2277 if (contextData && contextData->activityLogger()) { | 2312 if (contextData && contextData->activityLogger()) { |
2278 v8::Handle<v8::Value> loggerArg[] = { jsValue }; | 2313 v8::Handle<v8::Value> loggerArg[] = { jsValue }; |
2279 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForIsolatedWorldsPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); | 2314 contextData->activityLogger()->log("TestObjectPython.activityLoggingAcce
ssForIsolatedWorldsPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter"); |
(...skipping 10 matching lines...) Expand all Loading... |
2290 | 2325 |
2291 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCall
backInfo<v8::Value>& info) | 2326 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCall
backInfo<v8::Value>& info) |
2292 { | 2327 { |
2293 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2328 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2294 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetterForMainWorld(info); | 2329 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetterForMainWorld(info); |
2295 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2330 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2296 } | 2331 } |
2297 | 2332 |
2298 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterForMainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallb
ackInfo<void>& info) | 2333 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterForMainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallb
ackInfo<void>& info) |
2299 { | 2334 { |
| 2335 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gAccessForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", info
.Holder(), info.GetIsolate()); |
2300 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2336 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2301 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2337 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2302 imp->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); | 2338 imp->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); |
2303 } | 2339 } |
2304 | 2340 |
2305 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) | 2341 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) |
2306 { | 2342 { |
2307 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2343 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2308 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetterForMainWorld(jsValue, info); | 2344 TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetterForMainWorld(jsValue, info); |
2309 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2345 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2310 } | 2346 } |
2311 | 2347 |
2312 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) | 2348 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(co
nst v8::PropertyCallbackInfo<v8::Value>& info) |
2313 { | 2349 { |
2314 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2350 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2315 v8SetReturnValueInt(info, imp->activityLoggingGetterPerWorldBindingsLongAttr
ibute()); | 2351 v8SetReturnValueInt(info, imp->activityLoggingGetterPerWorldBindingsLongAttr
ibute()); |
2316 } | 2352 } |
2317 | 2353 |
2318 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2354 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCal
lback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2319 { | 2355 { |
2320 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2356 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2321 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2357 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2322 if (contextData && contextData->activityLogger()) | 2358 if (contextData && contextData->activityLogger()) |
2323 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2359 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2324 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeGetter(info); | 2360 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeGetter(info); |
2325 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2361 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2326 } | 2362 } |
2327 | 2363 |
2328 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2364 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8
::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2329 { | 2365 { |
| 2366 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gGetterPerWorldBindingsLongAttribute", "TestObjectPython", info.Holder(), info.G
etIsolate()); |
2330 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2367 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2331 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2368 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2332 imp->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue); | 2369 imp->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue); |
2333 } | 2370 } |
2334 | 2371 |
2335 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCal
lbackInfo<void>& info) | 2372 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCal
lback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCal
lbackInfo<void>& info) |
2336 { | 2373 { |
2337 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2374 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2338 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeSetter(jsValue, info); | 2375 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeSetter(jsValue, info); |
2339 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2376 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2340 } | 2377 } |
2341 | 2378 |
2342 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterFor
MainWorld(const v8::PropertyCallbackInfo<v8::Value>& info) | 2379 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterFor
MainWorld(const v8::PropertyCallbackInfo<v8::Value>& info) |
2343 { | 2380 { |
2344 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2381 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2345 v8SetReturnValueInt(info, imp->activityLoggingGetterPerWorldBindingsLongAttr
ibute()); | 2382 v8SetReturnValueInt(info, imp->activityLoggingGetterPerWorldBindingsLongAttr
ibute()); |
2346 } | 2383 } |
2347 | 2384 |
2348 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCal
lbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Valu
e>& info) | 2385 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCal
lbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Valu
e>& info) |
2349 { | 2386 { |
2350 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2387 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2351 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2388 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2352 if (contextData && contextData->activityLogger()) | 2389 if (contextData && contextData->activityLogger()) |
2353 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2390 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2354 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeGetterForMainWorld(info); | 2391 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeGetterForMainWorld(info); |
2355 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2392 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2356 } | 2393 } |
2357 | 2394 |
2358 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterFor
MainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& in
fo) | 2395 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterFor
MainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& in
fo) |
2359 { | 2396 { |
| 2397 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gGetterPerWorldBindingsLongAttribute", "TestObjectPython", info.Holder(), info.G
etIsolate()); |
2360 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2398 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2361 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2399 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2362 imp->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue); | 2400 imp->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue); |
2363 } | 2401 } |
2364 | 2402 |
2365 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCal
lbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) | 2403 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCal
lbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8:
:PropertyCallbackInfo<void>& info) |
2366 { | 2404 { |
2367 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2405 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2368 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeSetterForMainWorld(jsValue, info); | 2406 TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttribu
teAttributeSetterForMainWorld(jsValue, info); |
2369 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2407 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2370 } | 2408 } |
2371 | 2409 |
2372 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) | 2410 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) |
2373 { | 2411 { |
2374 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2412 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2375 v8SetReturnValueInt(info, imp->activityLoggingGetterForIsolatedWorldsPerWorl
dBindingsLongAttribute()); | 2413 v8SetReturnValueInt(info, imp->activityLoggingGetterForIsolatedWorldsPerWorl
dBindingsLongAttribute()); |
2376 } | 2414 } |
2377 | 2415 |
2378 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8:
:Value>& info) | 2416 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8:
:Value>& info) |
2379 { | 2417 { |
2380 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2418 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2381 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); | 2419 V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->Ge
tCurrentContext()); |
2382 if (contextData && contextData->activityLogger()) | 2420 if (contextData && contextData->activityLogger()) |
2383 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter"); | 2421 contextData->activityLogger()->log("TestObjectPython.activityLoggingGett
erForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter"); |
2384 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetter(info); | 2422 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetter(info); |
2385 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2423 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2386 } | 2424 } |
2387 | 2425 |
2388 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void
>& info) | 2426 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void
>& info) |
2389 { | 2427 { |
| 2428 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gGetterForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", info
.Holder(), info.GetIsolate()); |
2390 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2429 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2391 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2430 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2392 imp->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); | 2431 imp->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); |
2393 } | 2432 } |
2394 | 2433 |
2395 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, cons
t v8::PropertyCallbackInfo<void>& info) | 2434 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, cons
t v8::PropertyCallbackInfo<void>& info) |
2396 { | 2435 { |
2397 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2436 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2398 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetter(jsValue, info); | 2437 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetter(jsValue, info); |
2399 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2438 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2400 } | 2439 } |
2401 | 2440 |
2402 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info) | 2441 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info) |
2403 { | 2442 { |
2404 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2443 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2405 v8SetReturnValueInt(info, imp->activityLoggingGetterForIsolatedWorldsPerWorl
dBindingsLongAttribute()); | 2444 v8SetReturnValueInt(info, imp->activityLoggingGetterForIsolatedWorldsPerWorl
dBindingsLongAttribute()); |
2406 } | 2445 } |
2407 | 2446 |
2408 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCall
backInfo<v8::Value>& info) | 2447 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCall
backInfo<v8::Value>& info) |
2409 { | 2448 { |
2410 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2449 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2411 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetterForMainWorld(info); | 2450 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeGetterForMainWorld(info); |
2412 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2451 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2413 } | 2452 } |
2414 | 2453 |
2415 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterForMainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallb
ackInfo<void>& info) | 2454 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterForMainWorld(v8::Local<v8::Value> jsValue, const v8::PropertyCallb
ackInfo<void>& info) |
2416 { | 2455 { |
| 2456 ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggin
gGetterForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", info
.Holder(), info.GetIsolate()); |
2417 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2457 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2418 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2458 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2419 imp->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); | 2459 imp->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(
cppValue); |
2420 } | 2460 } |
2421 | 2461 |
2422 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) | 2462 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeA
ttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> j
sValue, const v8::PropertyCallbackInfo<void>& info) |
2423 { | 2463 { |
2424 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2464 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2425 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetterForMainWorld(jsValue, info); | 2465 TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBi
ndingsLongAttributeAttributeSetterForMainWorld(jsValue, info); |
2426 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2466 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2427 } | 2467 } |
2428 | 2468 |
(...skipping 11 matching lines...) Expand all Loading... |
2440 { | 2480 { |
2441 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2481 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2442 TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeGetter(info
); | 2482 TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeGetter(info
); |
2443 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2483 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2444 } | 2484 } |
2445 | 2485 |
2446 static void raisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> jsV
alue, const v8::PropertyCallbackInfo<void>& info) | 2486 static void raisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> jsV
alue, const v8::PropertyCallbackInfo<void>& info) |
2447 { | 2487 { |
2448 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); | 2488 ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptio
nLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2449 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2489 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2450 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2490 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2451 imp->setRaisesExceptionLongAttribute(cppValue, exceptionState); | 2491 imp->setRaisesExceptionLongAttribute(cppValue, exceptionState); |
2452 exceptionState.throwIfNeeded(); | 2492 exceptionState.throwIfNeeded(); |
2453 } | 2493 } |
2454 | 2494 |
2455 static void raisesExceptionLongAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2495 static void raisesExceptionLongAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2456 { | 2496 { |
2457 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2497 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2458 TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeSetter(jsVa
lue, info); | 2498 TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeSetter(jsVa
lue, info); |
2459 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2499 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2460 } | 2500 } |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2554 | 2594 |
2555 static void reflectLongAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) | 2595 static void reflectLongAttributeAttributeGetterCallback(v8::Local<v8::String>, c
onst v8::PropertyCallbackInfo<v8::Value>& info) |
2556 { | 2596 { |
2557 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2597 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2558 TestObjectPythonV8Internal::reflectLongAttributeAttributeGetter(info); | 2598 TestObjectPythonV8Internal::reflectLongAttributeAttributeGetter(info); |
2559 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2599 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2560 } | 2600 } |
2561 | 2601 |
2562 static void reflectLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, co
nst v8::PropertyCallbackInfo<void>& info) | 2602 static void reflectLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, co
nst v8::PropertyCallbackInfo<void>& info) |
2563 { | 2603 { |
| 2604 ExceptionState exceptionState(ExceptionState::SetterContext, "reflectLongAtt
ribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2564 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2605 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2565 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2606 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2566 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2607 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2567 imp->setIntegralAttribute(HTMLNames::reflectlongattributeAttr, cppValue); | 2608 imp->setIntegralAttribute(HTMLNames::reflectlongattributeAttr, cppValue); |
2568 } | 2609 } |
2569 | 2610 |
2570 static void reflectLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2611 static void reflectLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v
8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2571 { | 2612 { |
2572 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2613 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2573 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2614 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2574 TestObjectPythonV8Internal::reflectLongAttributeAttributeSetter(jsValue, inf
o); | 2615 TestObjectPythonV8Internal::reflectLongAttributeAttributeSetter(jsValue, inf
o); |
2575 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2616 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2576 } | 2617 } |
2577 | 2618 |
2578 static void reflectUnsignedShortAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) | 2619 static void reflectUnsignedShortAttributeAttributeGetter(const v8::PropertyCallb
ackInfo<v8::Value>& info) |
2579 { | 2620 { |
2580 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2621 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2581 v8SetReturnValueUnsigned(info, std::max(0, imp->fastGetAttribute(HTMLNames::
reflectunsignedshortattributeAttr))); | 2622 v8SetReturnValueUnsigned(info, std::max(0, imp->fastGetAttribute(HTMLNames::
reflectunsignedshortattributeAttr))); |
2582 } | 2623 } |
2583 | 2624 |
2584 static void reflectUnsignedShortAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2625 static void reflectUnsignedShortAttributeAttributeGetterCallback(v8::Local<v8::S
tring>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2585 { | 2626 { |
2586 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2627 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2587 TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeGetter(inf
o); | 2628 TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeGetter(inf
o); |
2588 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2629 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2589 } | 2630 } |
2590 | 2631 |
2591 static void reflectUnsignedShortAttributeAttributeSetter(v8::Local<v8::Value> js
Value, const v8::PropertyCallbackInfo<void>& info) | 2632 static void reflectUnsignedShortAttributeAttributeSetter(v8::Local<v8::Value> js
Value, const v8::PropertyCallbackInfo<void>& info) |
2592 { | 2633 { |
| 2634 ExceptionState exceptionState(ExceptionState::SetterContext, "reflectUnsigne
dShortAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2593 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2635 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2594 V8TRYCATCH_VOID(unsigned, cppValue, toUInt16(jsValue)); | 2636 V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt16(jsValue, exceptionSta
te), exceptionState); |
2595 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2637 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2596 imp->setAttribute(HTMLNames::reflectunsignedshortattributeAttr, cppValue); | 2638 imp->setAttribute(HTMLNames::reflectunsignedshortattributeAttr, cppValue); |
2597 } | 2639 } |
2598 | 2640 |
2599 static void reflectUnsignedShortAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info
) | 2641 static void reflectUnsignedShortAttributeAttributeSetterCallback(v8::Local<v8::S
tring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info
) |
2600 { | 2642 { |
2601 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2643 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2602 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2644 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2603 TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeSetter(jsV
alue, info); | 2645 TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeSetter(jsV
alue, info); |
2604 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2646 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2605 } | 2647 } |
2606 | 2648 |
2607 static void reflectUnsignedLongAttributeAttributeGetter(const v8::PropertyCallba
ckInfo<v8::Value>& info) | 2649 static void reflectUnsignedLongAttributeAttributeGetter(const v8::PropertyCallba
ckInfo<v8::Value>& info) |
2608 { | 2650 { |
2609 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2651 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2610 v8SetReturnValueUnsigned(info, std::max(0, imp->getIntegralAttribute(HTMLNam
es::reflectunsignedlongattributeAttr))); | 2652 v8SetReturnValueUnsigned(info, std::max(0, imp->getIntegralAttribute(HTMLNam
es::reflectunsignedlongattributeAttr))); |
2611 } | 2653 } |
2612 | 2654 |
2613 static void reflectUnsignedLongAttributeAttributeGetterCallback(v8::Local<v8::St
ring>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2655 static void reflectUnsignedLongAttributeAttributeGetterCallback(v8::Local<v8::St
ring>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2614 { | 2656 { |
2615 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2657 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2616 TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeGetter(info
); | 2658 TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeGetter(info
); |
2617 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2659 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2618 } | 2660 } |
2619 | 2661 |
2620 static void reflectUnsignedLongAttributeAttributeSetter(v8::Local<v8::Value> jsV
alue, const v8::PropertyCallbackInfo<void>& info) | 2662 static void reflectUnsignedLongAttributeAttributeSetter(v8::Local<v8::Value> jsV
alue, const v8::PropertyCallbackInfo<void>& info) |
2621 { | 2663 { |
| 2664 ExceptionState exceptionState(ExceptionState::SetterContext, "reflectUnsigne
dLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2622 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2665 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2623 V8TRYCATCH_VOID(unsigned, cppValue, toUInt32(jsValue)); | 2666 V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt32(jsValue, exceptionSta
te), exceptionState); |
2624 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2667 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2625 imp->setUnsignedIntegralAttribute(HTMLNames::reflectunsignedlongattributeAtt
r, cppValue); | 2668 imp->setUnsignedIntegralAttribute(HTMLNames::reflectunsignedlongattributeAtt
r, cppValue); |
2626 } | 2669 } |
2627 | 2670 |
2628 static void reflectUnsignedLongAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2671 static void reflectUnsignedLongAttributeAttributeSetterCallback(v8::Local<v8::St
ring>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2629 { | 2672 { |
2630 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2673 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2631 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; | 2674 CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope; |
2632 TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeSetter(jsVa
lue, info); | 2675 TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeSetter(jsVa
lue, info); |
2633 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2676 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2828 | 2871 |
2829 static void runtimeEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::Str
ing>, const v8::PropertyCallbackInfo<v8::Value>& info) | 2872 static void runtimeEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::Str
ing>, const v8::PropertyCallbackInfo<v8::Value>& info) |
2830 { | 2873 { |
2831 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2874 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2832 TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeGetter(info)
; | 2875 TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeGetter(info)
; |
2833 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2876 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2834 } | 2877 } |
2835 | 2878 |
2836 static void runtimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> jsVa
lue, const v8::PropertyCallbackInfo<void>& info) | 2879 static void runtimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> jsVa
lue, const v8::PropertyCallbackInfo<void>& info) |
2837 { | 2880 { |
| 2881 ExceptionState exceptionState(ExceptionState::SetterContext, "runtimeEnabled
LongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2838 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2882 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2839 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2883 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2840 imp->setRuntimeEnabledLongAttribute(cppValue); | 2884 imp->setRuntimeEnabledLongAttribute(cppValue); |
2841 } | 2885 } |
2842 | 2886 |
2843 static void runtimeEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2887 static void runtimeEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::Str
ing>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2844 { | 2888 { |
2845 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2889 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2846 TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeSetter(jsVal
ue, info); | 2890 TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeSetter(jsVal
ue, info); |
2847 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2891 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2848 } | 2892 } |
2849 | 2893 |
(...skipping 10 matching lines...) Expand all Loading... |
2860 { | 2904 { |
2861 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2905 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2862 TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeG
etter(info); | 2906 TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeG
etter(info); |
2863 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2907 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2864 } | 2908 } |
2865 #endif // ENABLE(CONDITION) | 2909 #endif // ENABLE(CONDITION) |
2866 | 2910 |
2867 #if ENABLE(CONDITION) | 2911 #if ENABLE(CONDITION) |
2868 static void conditionalRuntimeEnabledLongAttributeAttributeSetter(v8::Local<v8::
Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2912 static void conditionalRuntimeEnabledLongAttributeAttributeSetter(v8::Local<v8::
Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2869 { | 2913 { |
| 2914 ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalRun
timeEnabledLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate())
; |
2870 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2915 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2871 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2916 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2872 imp->setConditionalRuntimeEnabledLongAttribute(cppValue); | 2917 imp->setConditionalRuntimeEnabledLongAttribute(cppValue); |
2873 } | 2918 } |
2874 #endif // ENABLE(CONDITION) | 2919 #endif // ENABLE(CONDITION) |
2875 | 2920 |
2876 #if ENABLE(CONDITION) | 2921 #if ENABLE(CONDITION) |
2877 static void conditionalRuntimeEnabledLongAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<vo
id>& info) | 2922 static void conditionalRuntimeEnabledLongAttributeAttributeSetterCallback(v8::Lo
cal<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<vo
id>& info) |
2878 { | 2923 { |
2879 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2924 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2880 TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeS
etter(jsValue, info); | 2925 TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeS
etter(jsValue, info); |
2881 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2926 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2919 { | 2964 { |
2920 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 2965 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
2921 TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeGette
r(info); | 2966 TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeGette
r(info); |
2922 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2967 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2923 } | 2968 } |
2924 | 2969 |
2925 static void setterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Valu
e> jsValue, const v8::PropertyCallbackInfo<void>& info) | 2970 static void setterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Valu
e> jsValue, const v8::PropertyCallbackInfo<void>& info) |
2926 { | 2971 { |
2927 ExceptionState exceptionState(ExceptionState::SetterContext, "setterRaisesEx
ceptionLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); | 2972 ExceptionState exceptionState(ExceptionState::SetterContext, "setterRaisesEx
ceptionLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
2928 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 2973 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
2929 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 2974 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
2930 imp->setSetterRaisesExceptionLongAttribute(cppValue, exceptionState); | 2975 imp->setSetterRaisesExceptionLongAttribute(cppValue, exceptionState); |
2931 exceptionState.throwIfNeeded(); | 2976 exceptionState.throwIfNeeded(); |
2932 } | 2977 } |
2933 | 2978 |
2934 static void setterRaisesExceptionLongAttributeAttributeSetterCallback(v8::Local<
v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>&
info) | 2979 static void setterRaisesExceptionLongAttributeAttributeSetterCallback(v8::Local<
v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>&
info) |
2935 { | 2980 { |
2936 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 2981 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
2937 TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeSette
r(jsValue, info); | 2982 TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeSette
r(jsValue, info); |
2938 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 2983 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
2939 } | 2984 } |
(...skipping 208 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3148 | 3193 |
3149 static void unforgeableLongAttributeAttributeGetterCallback(v8::Local<v8::String
>, const v8::PropertyCallbackInfo<v8::Value>& info) | 3194 static void unforgeableLongAttributeAttributeGetterCallback(v8::Local<v8::String
>, const v8::PropertyCallbackInfo<v8::Value>& info) |
3150 { | 3195 { |
3151 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); | 3196 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); |
3152 TestObjectPythonV8Internal::unforgeableLongAttributeAttributeGetter(info); | 3197 TestObjectPythonV8Internal::unforgeableLongAttributeAttributeGetter(info); |
3153 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3198 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3154 } | 3199 } |
3155 | 3200 |
3156 static void unforgeableLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue
, const v8::PropertyCallbackInfo<void>& info) | 3201 static void unforgeableLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue
, const v8::PropertyCallbackInfo<void>& info) |
3157 { | 3202 { |
| 3203 ExceptionState exceptionState(ExceptionState::SetterContext, "unforgeableLon
gAttribute", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3158 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3204 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3159 V8TRYCATCH_VOID(int, cppValue, toInt32(jsValue)); | 3205 V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), e
xceptionState); |
3160 imp->setUnforgeableLongAttribute(cppValue); | 3206 imp->setUnforgeableLongAttribute(cppValue); |
3161 } | 3207 } |
3162 | 3208 |
3163 static void unforgeableLongAttributeAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) | 3209 static void unforgeableLongAttributeAttributeSetterCallback(v8::Local<v8::String
>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info) |
3164 { | 3210 { |
3165 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); | 3211 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); |
3166 TestObjectPythonV8Internal::unforgeableLongAttributeAttributeSetter(jsValue,
info); | 3212 TestObjectPythonV8Internal::unforgeableLongAttributeAttributeSetter(jsValue,
info); |
3167 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3213 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3168 } | 3214 } |
3169 | 3215 |
(...skipping 273 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3443 | 3489 |
3444 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) | 3490 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8
::Value>& info) |
3445 { | 3491 { |
3446 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3492 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3447 TestObjectPythonV8Internal::voidMethodBooleanArgMethod(info); | 3493 TestObjectPythonV8Internal::voidMethodBooleanArgMethod(info); |
3448 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3494 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3449 } | 3495 } |
3450 | 3496 |
3451 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3497 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3452 { | 3498 { |
| 3499 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodB
yteArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3453 if (UNLIKELY(info.Length() < 1)) { | 3500 if (UNLIKELY(info.Length() < 1)) { |
3454 throwTypeError(ExceptionMessages::failedToExecute("voidMethodByteArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3501 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3502 exceptionState.throwIfNeeded(); |
3455 return; | 3503 return; |
3456 } | 3504 } |
3457 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3505 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3458 V8TRYCATCH_VOID(int, byteArg, toInt8(info[0])); | 3506 V8TRYCATCH_EXCEPTION_VOID(int, byteArg, toInt8(info[0], exceptionState), exc
eptionState); |
3459 imp->voidMethodByteArg(byteArg); | 3507 imp->voidMethodByteArg(byteArg); |
3460 } | 3508 } |
3461 | 3509 |
3462 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3510 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3463 { | 3511 { |
3464 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3512 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3465 TestObjectPythonV8Internal::voidMethodByteArgMethod(info); | 3513 TestObjectPythonV8Internal::voidMethodByteArgMethod(info); |
3466 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3514 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3467 } | 3515 } |
3468 | 3516 |
(...skipping 28 matching lines...) Expand all Loading... |
3497 | 3545 |
3498 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3546 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3499 { | 3547 { |
3500 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3548 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3501 TestObjectPythonV8Internal::voidMethodFloatArgMethod(info); | 3549 TestObjectPythonV8Internal::voidMethodFloatArgMethod(info); |
3502 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3550 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3503 } | 3551 } |
3504 | 3552 |
3505 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 3553 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
3506 { | 3554 { |
| 3555 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3507 if (UNLIKELY(info.Length() < 1)) { | 3556 if (UNLIKELY(info.Length() < 1)) { |
3508 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArg", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 3557 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3558 exceptionState.throwIfNeeded(); |
3509 return; | 3559 return; |
3510 } | 3560 } |
3511 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3561 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3512 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 3562 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
3513 imp->voidMethodLongArg(longArg); | 3563 imp->voidMethodLongArg(longArg); |
3514 } | 3564 } |
3515 | 3565 |
3516 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3566 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3517 { | 3567 { |
3518 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3568 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3519 TestObjectPythonV8Internal::voidMethodLongArgMethod(info); | 3569 TestObjectPythonV8Internal::voidMethodLongArgMethod(info); |
3520 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3570 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3521 } | 3571 } |
3522 | 3572 |
3523 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) | 3573 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value
>& info) |
3524 { | 3574 { |
| 3575 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3525 if (UNLIKELY(info.Length() < 1)) { | 3576 if (UNLIKELY(info.Length() < 1)) { |
3526 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongLongArg
", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())),
info.GetIsolate()); | 3577 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3578 exceptionState.throwIfNeeded(); |
3527 return; | 3579 return; |
3528 } | 3580 } |
3529 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3581 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3530 V8TRYCATCH_VOID(long long, longLongArg, toInt64(info[0])); | 3582 V8TRYCATCH_EXCEPTION_VOID(long long, longLongArg, toInt64(info[0], exception
State), exceptionState); |
3531 imp->voidMethodLongLongArg(longLongArg); | 3583 imp->voidMethodLongLongArg(longLongArg); |
3532 } | 3584 } |
3533 | 3585 |
3534 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) | 3586 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v
8::Value>& info) |
3535 { | 3587 { |
3536 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3588 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3537 TestObjectPythonV8Internal::voidMethodLongLongArgMethod(info); | 3589 TestObjectPythonV8Internal::voidMethodLongLongArgMethod(info); |
3538 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3590 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3539 } | 3591 } |
3540 | 3592 |
3541 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3593 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3542 { | 3594 { |
| 3595 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO
ctetArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3543 if (UNLIKELY(info.Length() < 1)) { | 3596 if (UNLIKELY(info.Length() < 1)) { |
3544 throwTypeError(ExceptionMessages::failedToExecute("voidMethodOctetArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); | 3597 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3598 exceptionState.throwIfNeeded(); |
3545 return; | 3599 return; |
3546 } | 3600 } |
3547 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3601 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3548 V8TRYCATCH_VOID(unsigned, octetArg, toUInt8(info[0])); | 3602 V8TRYCATCH_EXCEPTION_VOID(unsigned, octetArg, toUInt8(info[0], exceptionStat
e), exceptionState); |
3549 imp->voidMethodOctetArg(octetArg); | 3603 imp->voidMethodOctetArg(octetArg); |
3550 } | 3604 } |
3551 | 3605 |
3552 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3606 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3553 { | 3607 { |
3554 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3608 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3555 TestObjectPythonV8Internal::voidMethodOctetArgMethod(info); | 3609 TestObjectPythonV8Internal::voidMethodOctetArgMethod(info); |
3556 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3610 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3557 } | 3611 } |
3558 | 3612 |
3559 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) | 3613 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>&
info) |
3560 { | 3614 { |
| 3615 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
hortArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3561 if (UNLIKELY(info.Length() < 1)) { | 3616 if (UNLIKELY(info.Length() < 1)) { |
3562 throwTypeError(ExceptionMessages::failedToExecute("voidMethodShortArg",
"TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), in
fo.GetIsolate()); | 3617 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3618 exceptionState.throwIfNeeded(); |
3563 return; | 3619 return; |
3564 } | 3620 } |
3565 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3621 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3566 V8TRYCATCH_VOID(int, shortArg, toInt16(info[0])); | 3622 V8TRYCATCH_EXCEPTION_VOID(int, shortArg, toInt16(info[0], exceptionState), e
xceptionState); |
3567 imp->voidMethodShortArg(shortArg); | 3623 imp->voidMethodShortArg(shortArg); |
3568 } | 3624 } |
3569 | 3625 |
3570 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3626 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3571 { | 3627 { |
3572 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3628 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3573 TestObjectPythonV8Internal::voidMethodShortArgMethod(info); | 3629 TestObjectPythonV8Internal::voidMethodShortArgMethod(info); |
3574 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3630 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3575 } | 3631 } |
3576 | 3632 |
3577 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 3633 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
3578 { | 3634 { |
| 3635 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU
nsignedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3579 if (UNLIKELY(info.Length() < 1)) { | 3636 if (UNLIKELY(info.Length() < 1)) { |
3580 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length(
))), info.GetIsolate()); | 3637 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3638 exceptionState.throwIfNeeded(); |
3581 return; | 3639 return; |
3582 } | 3640 } |
3583 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3641 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3584 V8TRYCATCH_VOID(unsigned, unsignedLongArg, toUInt32(info[0])); | 3642 V8TRYCATCH_EXCEPTION_VOID(unsigned, unsignedLongArg, toUInt32(info[0], excep
tionState), exceptionState); |
3585 imp->voidMethodUnsignedLongArg(unsignedLongArg); | 3643 imp->voidMethodUnsignedLongArg(unsignedLongArg); |
3586 } | 3644 } |
3587 | 3645 |
3588 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 3646 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
3589 { | 3647 { |
3590 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3648 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3591 TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethod(info); | 3649 TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethod(info); |
3592 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3650 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3593 } | 3651 } |
3594 | 3652 |
3595 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) | 3653 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) |
3596 { | 3654 { |
| 3655 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU
nsignedLongLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3597 if (UNLIKELY(info.Length() < 1)) { | 3656 if (UNLIKELY(info.Length() < 1)) { |
3598 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedLon
gLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); | 3657 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3658 exceptionState.throwIfNeeded(); |
3599 return; | 3659 return; |
3600 } | 3660 } |
3601 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3661 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3602 V8TRYCATCH_VOID(unsigned long long, unsignedLongLongArg, toUInt64(info[0])); | 3662 V8TRYCATCH_EXCEPTION_VOID(unsigned long long, unsignedLongLongArg, toUInt64(
info[0], exceptionState), exceptionState); |
3603 imp->voidMethodUnsignedLongLongArg(unsignedLongLongArg); | 3663 imp->voidMethodUnsignedLongLongArg(unsignedLongLongArg); |
3604 } | 3664 } |
3605 | 3665 |
3606 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 3666 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
3607 { | 3667 { |
3608 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3668 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3609 TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethod(info); | 3669 TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethod(info); |
3610 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3670 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3611 } | 3671 } |
3612 | 3672 |
3613 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) | 3673 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) |
3614 { | 3674 { |
| 3675 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodU
nsignedShortArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
3615 if (UNLIKELY(info.Length() < 1)) { | 3676 if (UNLIKELY(info.Length() < 1)) { |
3616 throwTypeError(ExceptionMessages::failedToExecute("voidMethodUnsignedSho
rtArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length
())), info.GetIsolate()); | 3677 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 3678 exceptionState.throwIfNeeded(); |
3617 return; | 3679 return; |
3618 } | 3680 } |
3619 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3681 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3620 V8TRYCATCH_VOID(unsigned, unsignedShortArg, toUInt16(info[0])); | 3682 V8TRYCATCH_EXCEPTION_VOID(unsigned, unsignedShortArg, toUInt16(info[0], exce
ptionState), exceptionState); |
3621 imp->voidMethodUnsignedShortArg(unsignedShortArg); | 3683 imp->voidMethodUnsignedShortArg(unsignedShortArg); |
3622 } | 3684 } |
3623 | 3685 |
3624 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 3686 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
3625 { | 3687 { |
3626 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3688 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3627 TestObjectPythonV8Internal::voidMethodUnsignedShortArgMethod(info); | 3689 TestObjectPythonV8Internal::voidMethodUnsignedShortArgMethod(info); |
3628 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3690 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3629 } | 3691 } |
3630 | 3692 |
(...skipping 23 matching lines...) Expand all Loading... |
3654 | 3716 |
3655 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 3717 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
3656 { | 3718 { |
3657 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3719 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3658 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); | 3720 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethod(info); |
3659 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3721 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3660 } | 3722 } |
3661 | 3723 |
3662 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) | 3724 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb
ackInfo<v8::Value>& info) |
3663 { | 3725 { |
| 3726 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgTestInterfaceEmptyArg", "TestObjectPython", info.Holder(), info.GetIsolate
()); |
3664 if (UNLIKELY(info.Length() < 2)) { | 3727 if (UNLIKELY(info.Length() < 2)) { |
3665 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgTest
InterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2,
info.Length())), info.GetIsolate()); | 3728 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, i
nfo.Length())); |
| 3729 exceptionState.throwIfNeeded(); |
3666 return; | 3730 return; |
3667 } | 3731 } |
3668 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 3732 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
3669 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 3733 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
3670 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); | 3734 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); |
3671 imp->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg); | 3735 imp->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg); |
3672 } | 3736 } |
3673 | 3737 |
3674 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 3738 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
3675 { | 3739 { |
3676 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 3740 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
3677 TestObjectPythonV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(inf
o); | 3741 TestObjectPythonV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(inf
o); |
3678 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 3742 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
3679 } | 3743 } |
(...skipping 805 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4485 | 4549 |
4486 static void voidMethodSequenceDictionaryArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 4550 static void voidMethodSequenceDictionaryArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
4487 { | 4551 { |
4488 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4552 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4489 TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethod(info); | 4553 TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethod(info); |
4490 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4554 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4491 } | 4555 } |
4492 | 4556 |
4493 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) | 4557 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::
Value>& info) |
4494 { | 4558 { |
| 4559 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodS
tringArgLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4495 if (UNLIKELY(info.Length() < 2)) { | 4560 if (UNLIKELY(info.Length() < 2)) { |
4496 throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgLo
ngArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length
())), info.GetIsolate()); | 4561 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, i
nfo.Length())); |
| 4562 exceptionState.throwIfNeeded(); |
4497 return; | 4563 return; |
4498 } | 4564 } |
4499 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4565 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4500 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; | 4566 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0])
; |
4501 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); | 4567 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[1], exceptionState), ex
ceptionState); |
4502 imp->voidMethodStringArgLongArg(stringArg, longArg); | 4568 imp->voidMethodStringArgLongArg(stringArg, longArg); |
4503 } | 4569 } |
4504 | 4570 |
4505 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) | 4571 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackI
nfo<v8::Value>& info) |
4506 { | 4572 { |
4507 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4573 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4508 TestObjectPythonV8Internal::voidMethodStringArgLongArgMethod(info); | 4574 TestObjectPythonV8Internal::voidMethodStringArgLongArgMethod(info); |
4509 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4575 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4510 } | 4576 } |
4511 | 4577 |
(...skipping 28 matching lines...) Expand all Loading... |
4540 | 4606 |
4541 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4607 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4542 { | 4608 { |
4543 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4609 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4544 TestObjectPythonV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(in
fo); | 4610 TestObjectPythonV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(in
fo); |
4545 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4611 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4546 } | 4612 } |
4547 | 4613 |
4548 static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4614 static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4549 { | 4615 { |
| 4616 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodO
ptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4550 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4617 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4551 if (UNLIKELY(info.Length() <= 0)) { | 4618 if (UNLIKELY(info.Length() <= 0)) { |
4552 imp->voidMethodOptionalLongArg(); | 4619 imp->voidMethodOptionalLongArg(); |
4553 return; | 4620 return; |
4554 } | 4621 } |
4555 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[0])); | 4622 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionSt
ate), exceptionState); |
4556 imp->voidMethodOptionalLongArg(optionalLongArg); | 4623 imp->voidMethodOptionalLongArg(optionalLongArg); |
4557 } | 4624 } |
4558 | 4625 |
4559 static void voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 4626 static void voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
4560 { | 4627 { |
4561 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4628 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4562 TestObjectPythonV8Internal::voidMethodOptionalLongArgMethod(info); | 4629 TestObjectPythonV8Internal::voidMethodOptionalLongArgMethod(info); |
4563 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4630 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4564 } | 4631 } |
4565 | 4632 |
4566 static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 4633 static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
4567 { | 4634 { |
| 4635 ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringMetho
dOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4568 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4636 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4569 if (UNLIKELY(info.Length() <= 0)) { | 4637 if (UNLIKELY(info.Length() <= 0)) { |
4570 v8SetReturnValueString(info, imp->stringMethodOptionalLongArg(), info.Ge
tIsolate()); | 4638 v8SetReturnValueString(info, imp->stringMethodOptionalLongArg(), info.Ge
tIsolate()); |
4571 return; | 4639 return; |
4572 } | 4640 } |
4573 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[0])); | 4641 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionSt
ate), exceptionState); |
4574 v8SetReturnValueString(info, imp->stringMethodOptionalLongArg(optionalLongAr
g), info.GetIsolate()); | 4642 v8SetReturnValueString(info, imp->stringMethodOptionalLongArg(optionalLongAr
g), info.GetIsolate()); |
4575 } | 4643 } |
4576 | 4644 |
4577 static void stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) | 4645 static void stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallback
Info<v8::Value>& info) |
4578 { | 4646 { |
4579 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4647 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4580 TestObjectPythonV8Internal::stringMethodOptionalLongArgMethod(info); | 4648 TestObjectPythonV8Internal::stringMethodOptionalLongArgMethod(info); |
4581 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4649 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4582 } | 4650 } |
4583 | 4651 |
4584 static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) | 4652 static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCall
backInfo<v8::Value>& info) |
4585 { | 4653 { |
| 4654 ExceptionState exceptionState(ExceptionState::ExecutionContext, "testInterfa
ceEmptyMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolat
e()); |
4586 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4655 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4587 if (UNLIKELY(info.Length() <= 0)) { | 4656 if (UNLIKELY(info.Length() <= 0)) { |
4588 v8SetReturnValue(info, imp->testInterfaceEmptyMethodOptionalLongArg()); | 4657 v8SetReturnValue(info, imp->testInterfaceEmptyMethodOptionalLongArg()); |
4589 return; | 4658 return; |
4590 } | 4659 } |
4591 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[0])); | 4660 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionSt
ate), exceptionState); |
4592 v8SetReturnValue(info, imp->testInterfaceEmptyMethodOptionalLongArg(optional
LongArg)); | 4661 v8SetReturnValue(info, imp->testInterfaceEmptyMethodOptionalLongArg(optional
LongArg)); |
4593 } | 4662 } |
4594 | 4663 |
4595 static void testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4664 static void testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4596 { | 4665 { |
4597 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4666 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4598 TestObjectPythonV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(in
fo); | 4667 TestObjectPythonV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(in
fo); |
4599 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4668 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4600 } | 4669 } |
4601 | 4670 |
4602 static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4671 static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4603 { | 4672 { |
| 4673 ExceptionState exceptionState(ExceptionState::ExecutionContext, "longMethodO
ptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4604 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4674 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4605 if (UNLIKELY(info.Length() <= 0)) { | 4675 if (UNLIKELY(info.Length() <= 0)) { |
4606 v8SetReturnValueInt(info, imp->longMethodOptionalLongArg()); | 4676 v8SetReturnValueInt(info, imp->longMethodOptionalLongArg()); |
4607 return; | 4677 return; |
4608 } | 4678 } |
4609 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[0])); | 4679 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionSt
ate), exceptionState); |
4610 v8SetReturnValueInt(info, imp->longMethodOptionalLongArg(optionalLongArg)); | 4680 v8SetReturnValueInt(info, imp->longMethodOptionalLongArg(optionalLongArg)); |
4611 } | 4681 } |
4612 | 4682 |
4613 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 4683 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
4614 { | 4684 { |
4615 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4685 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4616 TestObjectPythonV8Internal::longMethodOptionalLongArgMethod(info); | 4686 TestObjectPythonV8Internal::longMethodOptionalLongArgMethod(info); |
4617 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4687 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4618 } | 4688 } |
4619 | 4689 |
4620 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) | 4690 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) |
4621 { | 4691 { |
| 4692 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4622 if (UNLIKELY(info.Length() < 1)) { | 4693 if (UNLIKELY(info.Length() < 1)) { |
4623 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 4694 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4695 exceptionState.throwIfNeeded(); |
4624 return; | 4696 return; |
4625 } | 4697 } |
4626 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4698 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4627 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4699 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4628 if (UNLIKELY(info.Length() <= 1)) { | 4700 if (UNLIKELY(info.Length() <= 1)) { |
4629 imp->voidMethodLongArgOptionalLongArg(longArg); | 4701 imp->voidMethodLongArgOptionalLongArg(longArg); |
4630 return; | 4702 return; |
4631 } | 4703 } |
4632 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[1])); | 4704 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[1], exceptionSt
ate), exceptionState); |
4633 imp->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg); | 4705 imp->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg); |
4634 } | 4706 } |
4635 | 4707 |
4636 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 4708 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
4637 { | 4709 { |
4638 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4710 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4639 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethod(info); | 4711 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethod(info); |
4640 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4712 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4641 } | 4713 } |
4642 | 4714 |
4643 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) | 4715 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::Func
tionCallbackInfo<v8::Value>& info) |
4644 { | 4716 { |
| 4717 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgOptionalLongArgOptionalLongArg", "TestObjectPython", info.Holder(), info.G
etIsolate()); |
4645 if (UNLIKELY(info.Length() < 1)) { | 4718 if (UNLIKELY(info.Length() < 1)) { |
4646 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalLongArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArg
uments(1, info.Length())), info.GetIsolate()); | 4719 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4720 exceptionState.throwIfNeeded(); |
4647 return; | 4721 return; |
4648 } | 4722 } |
4649 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4723 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4650 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4724 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4651 if (UNLIKELY(info.Length() <= 1)) { | 4725 if (UNLIKELY(info.Length() <= 1)) { |
4652 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg); | 4726 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg); |
4653 return; | 4727 return; |
4654 } | 4728 } |
4655 V8TRYCATCH_VOID(int, optionalLongArg1, toInt32(info[1])); | 4729 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg1, toInt32(info[1], exceptionS
tate), exceptionState); |
4656 if (UNLIKELY(info.Length() <= 2)) { | 4730 if (UNLIKELY(info.Length() <= 2)) { |
4657 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLo
ngArg1); | 4731 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLo
ngArg1); |
4658 return; | 4732 return; |
4659 } | 4733 } |
4660 V8TRYCATCH_VOID(int, optionalLongArg2, toInt32(info[2])); | 4734 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg2, toInt32(info[2], exceptionS
tate), exceptionState); |
4661 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongAr
g1, optionalLongArg2); | 4735 imp->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongAr
g1, optionalLongArg2); |
4662 } | 4736 } |
4663 | 4737 |
4664 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 4738 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
4665 { | 4739 { |
4666 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4740 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4667 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgM
ethod(info); | 4741 TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgM
ethod(info); |
4668 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4742 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4669 } | 4743 } |
4670 | 4744 |
4671 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 4745 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
4672 { | 4746 { |
| 4747 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodL
ongArgOptionalTestInterfaceEmptyArg", "TestObjectPython", info.Holder(), info.Ge
tIsolate()); |
4673 if (UNLIKELY(info.Length() < 1)) { | 4748 if (UNLIKELY(info.Length() < 1)) { |
4674 throwTypeError(ExceptionMessages::failedToExecute("voidMethodLongArgOpti
onalTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); | 4749 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4750 exceptionState.throwIfNeeded(); |
4675 return; | 4751 return; |
4676 } | 4752 } |
4677 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4753 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4678 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4754 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4679 if (UNLIKELY(info.Length() <= 1)) { | 4755 if (UNLIKELY(info.Length() <= 1)) { |
4680 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); | 4756 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg); |
4681 return; | 4757 return; |
4682 } | 4758 } |
4683 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); | 4759 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[1], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[1])) : 0); |
4684 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInt
erfaceEmpty); | 4760 imp->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInt
erfaceEmpty); |
4685 } | 4761 } |
4686 | 4762 |
4687 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 4763 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
4688 { | 4764 { |
4689 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4765 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4690 TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMe
thod(info); | 4766 TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMe
thod(info); |
4691 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4767 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4692 } | 4768 } |
4693 | 4769 |
4694 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) | 4770 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct
ionCallbackInfo<v8::Value>& info) |
4695 { | 4771 { |
| 4772 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodT
estInterfaceEmptyArgOptionalLongArg", "TestObjectPython", info.Holder(), info.Ge
tIsolate()); |
4696 if (UNLIKELY(info.Length() < 1)) { | 4773 if (UNLIKELY(info.Length() < 1)) { |
4697 throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfa
ceEmptyArgOptionalLongArg", "TestObjectPython", ExceptionMessages::notEnoughArgu
ments(1, info.Length())), info.GetIsolate()); | 4774 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4775 exceptionState.throwIfNeeded(); |
4698 return; | 4776 return; |
4699 } | 4777 } |
4700 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4778 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4701 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); | 4779 V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInter
faceEmpty::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))
? V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[0])) : 0); |
4702 if (UNLIKELY(info.Length() <= 1)) { | 4780 if (UNLIKELY(info.Length() <= 1)) { |
4703 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfac
eEmpty); | 4781 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfac
eEmpty); |
4704 return; | 4782 return; |
4705 } | 4783 } |
4706 V8TRYCATCH_VOID(int, longArg, toInt32(info[1])); | 4784 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[1], exceptionState), ex
ceptionState); |
4707 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmp
ty, longArg); | 4785 imp->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmp
ty, longArg); |
4708 } | 4786 } |
4709 | 4787 |
4710 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) | 4788 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v
8::FunctionCallbackInfo<v8::Value>& info) |
4711 { | 4789 { |
4712 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4790 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4713 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMe
thod(info); | 4791 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMe
thod(info); |
4714 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4792 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4715 } | 4793 } |
4716 | 4794 |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4807 | 4885 |
4808 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) | 4886 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCa
llback(const v8::FunctionCallbackInfo<v8::Value>& info) |
4809 { | 4887 { |
4810 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4888 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4811 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInter
faceEmptyArgMethod(info); | 4889 TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInter
faceEmptyArgMethod(info); |
4812 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4890 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4813 } | 4891 } |
4814 | 4892 |
4815 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4893 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4816 { | 4894 { |
| 4895 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodA", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4817 if (UNLIKELY(info.Length() < 1)) { | 4896 if (UNLIKELY(info.Length() < 1)) { |
4818 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4897 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4898 exceptionState.throwIfNeeded(); |
4819 return; | 4899 return; |
4820 } | 4900 } |
4821 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4901 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4822 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4902 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4823 imp->overloadedMethodA(longArg); | 4903 imp->overloadedMethodA(longArg); |
4824 } | 4904 } |
4825 | 4905 |
4826 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4906 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4827 { | 4907 { |
| 4908 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodA", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4828 if (UNLIKELY(info.Length() < 2)) { | 4909 if (UNLIKELY(info.Length() < 2)) { |
4829 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodA", "
TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length())), inf
o.GetIsolate()); | 4910 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, i
nfo.Length())); |
| 4911 exceptionState.throwIfNeeded(); |
4830 return; | 4912 return; |
4831 } | 4913 } |
4832 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4914 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4833 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 4915 V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), e
xceptionState); |
4834 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 4916 V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), e
xceptionState); |
4835 imp->overloadedMethodA(longArg1, longArg2); | 4917 imp->overloadedMethodA(longArg1, longArg2); |
4836 } | 4918 } |
4837 | 4919 |
4838 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4920 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4839 { | 4921 { |
4840 if (((info.Length() == 1))) { | 4922 if (((info.Length() == 1))) { |
4841 overloadedMethodA1Method(info); | 4923 overloadedMethodA1Method(info); |
4842 return; | 4924 return; |
4843 } | 4925 } |
4844 if (((info.Length() == 2))) { | 4926 if (((info.Length() == 2))) { |
(...skipping 12 matching lines...) Expand all Loading... |
4857 | 4939 |
4858 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4940 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4859 { | 4941 { |
4860 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 4942 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4861 TestObjectPythonV8Internal::overloadedMethodAMethod(info); | 4943 TestObjectPythonV8Internal::overloadedMethodAMethod(info); |
4862 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 4944 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4863 } | 4945 } |
4864 | 4946 |
4865 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4947 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4866 { | 4948 { |
| 4949 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodB", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4867 if (UNLIKELY(info.Length() < 1)) { | 4950 if (UNLIKELY(info.Length() < 1)) { |
4868 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4951 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4952 exceptionState.throwIfNeeded(); |
4869 return; | 4953 return; |
4870 } | 4954 } |
4871 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4955 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4872 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 4956 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4873 imp->overloadedMethodB(longArg); | 4957 imp->overloadedMethodB(longArg); |
4874 } | 4958 } |
4875 | 4959 |
4876 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 4960 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4877 { | 4961 { |
| 4962 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodB", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4878 if (UNLIKELY(info.Length() < 1)) { | 4963 if (UNLIKELY(info.Length() < 1)) { |
4879 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodB", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 4964 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 4965 exceptionState.throwIfNeeded(); |
4880 return; | 4966 return; |
4881 } | 4967 } |
4882 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 4968 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4883 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 4969 V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), e
xceptionState); |
4884 if (UNLIKELY(info.Length() <= 1)) { | 4970 if (UNLIKELY(info.Length() <= 1)) { |
4885 imp->overloadedMethodB(longArg1); | 4971 imp->overloadedMethodB(longArg1); |
4886 return; | 4972 return; |
4887 } | 4973 } |
4888 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 4974 V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), e
xceptionState); |
4889 imp->overloadedMethodB(longArg1, longArg2); | 4975 imp->overloadedMethodB(longArg1, longArg2); |
4890 } | 4976 } |
4891 | 4977 |
4892 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 4978 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4893 { | 4979 { |
4894 if (((info.Length() == 1))) { | 4980 if (((info.Length() == 1))) { |
4895 overloadedMethodB1Method(info); | 4981 overloadedMethodB1Method(info); |
4896 return; | 4982 return; |
4897 } | 4983 } |
4898 if (((info.Length() == 1)) || ((info.Length() == 2))) { | 4984 if (((info.Length() == 1)) || ((info.Length() == 2))) { |
(...skipping 12 matching lines...) Expand all Loading... |
4911 | 4997 |
4912 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 4998 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4913 { | 4999 { |
4914 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5000 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4915 TestObjectPythonV8Internal::overloadedMethodBMethod(info); | 5001 TestObjectPythonV8Internal::overloadedMethodBMethod(info); |
4916 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5002 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4917 } | 5003 } |
4918 | 5004 |
4919 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5005 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4920 { | 5006 { |
| 5007 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4921 if (UNLIKELY(info.Length() < 1)) { | 5008 if (UNLIKELY(info.Length() < 1)) { |
4922 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5009 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5010 exceptionState.throwIfNeeded(); |
4923 return; | 5011 return; |
4924 } | 5012 } |
4925 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5013 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4926 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5014 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4927 imp->overloadedMethodC(longArg); | 5015 imp->overloadedMethodC(longArg); |
4928 } | 5016 } |
4929 | 5017 |
4930 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5018 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4931 { | 5019 { |
| 5020 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodC", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4932 if (UNLIKELY(info.Length() < 1)) { | 5021 if (UNLIKELY(info.Length() < 1)) { |
4933 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodC", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5022 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5023 exceptionState.throwIfNeeded(); |
4934 return; | 5024 return; |
4935 } | 5025 } |
4936 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5026 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4937 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5027 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4938 V8TRYCATCH_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1)); | 5028 V8TRYCATCH_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1)); |
4939 imp->overloadedMethodC(longArg, longArgs); | 5029 imp->overloadedMethodC(longArg, longArgs); |
4940 } | 5030 } |
4941 | 5031 |
4942 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) | 5032 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& i
nfo) |
4943 { | 5033 { |
4944 if (((info.Length() == 1))) { | 5034 if (((info.Length() == 1))) { |
4945 overloadedMethodC1Method(info); | 5035 overloadedMethodC1Method(info); |
4946 return; | 5036 return; |
4947 } | 5037 } |
(...skipping 13 matching lines...) Expand all Loading... |
4961 | 5051 |
4962 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5052 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
4963 { | 5053 { |
4964 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5054 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
4965 TestObjectPythonV8Internal::overloadedMethodCMethod(info); | 5055 TestObjectPythonV8Internal::overloadedMethodCMethod(info); |
4966 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5056 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
4967 } | 5057 } |
4968 | 5058 |
4969 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5059 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4970 { | 5060 { |
| 5061 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodD", "TestObjectPython", info.Holder(), info.GetIsolate()); |
4971 if (UNLIKELY(info.Length() < 1)) { | 5062 if (UNLIKELY(info.Length() < 1)) { |
4972 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5063 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5064 exceptionState.throwIfNeeded(); |
4973 return; | 5065 return; |
4974 } | 5066 } |
4975 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5067 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
4976 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5068 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
4977 imp->overloadedMethodD(longArg); | 5069 imp->overloadedMethodD(longArg); |
4978 } | 5070 } |
4979 | 5071 |
4980 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5072 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
4981 { | 5073 { |
4982 if (UNLIKELY(info.Length() < 1)) { | 5074 if (UNLIKELY(info.Length() < 1)) { |
4983 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5075 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
4984 return; | 5076 return; |
4985 } | 5077 } |
4986 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5078 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
(...skipping 23 matching lines...) Expand all Loading... |
5010 | 5102 |
5011 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5103 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5012 { | 5104 { |
5013 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5105 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5014 TestObjectPythonV8Internal::overloadedMethodDMethod(info); | 5106 TestObjectPythonV8Internal::overloadedMethodDMethod(info); |
5015 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5107 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5016 } | 5108 } |
5017 | 5109 |
5018 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5110 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
5019 { | 5111 { |
| 5112 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodE", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5020 if (UNLIKELY(info.Length() < 1)) { | 5113 if (UNLIKELY(info.Length() < 1)) { |
5021 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5114 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5115 exceptionState.throwIfNeeded(); |
5022 return; | 5116 return; |
5023 } | 5117 } |
5024 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5118 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5025 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5119 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
5026 imp->overloadedMethodE(longArg); | 5120 imp->overloadedMethodE(longArg); |
5027 } | 5121 } |
5028 | 5122 |
5029 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5123 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
5030 { | 5124 { |
5031 if (UNLIKELY(info.Length() < 1)) { | 5125 if (UNLIKELY(info.Length() < 1)) { |
5032 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5126 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
5033 return; | 5127 return; |
5034 } | 5128 } |
5035 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5129 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
(...skipping 23 matching lines...) Expand all Loading... |
5059 | 5153 |
5060 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) | 5154 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::V
alue>& info) |
5061 { | 5155 { |
5062 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5156 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5063 TestObjectPythonV8Internal::overloadedMethodEMethod(info); | 5157 TestObjectPythonV8Internal::overloadedMethodEMethod(info); |
5064 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5158 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5065 } | 5159 } |
5066 | 5160 |
5067 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5161 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
5068 { | 5162 { |
| 5163 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedM
ethodF", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5069 if (UNLIKELY(info.Length() < 1)) { | 5164 if (UNLIKELY(info.Length() < 1)) { |
5070 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5165 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5166 exceptionState.throwIfNeeded(); |
5071 return; | 5167 return; |
5072 } | 5168 } |
5073 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5169 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5074 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5170 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
5075 imp->overloadedMethodF(longArg); | 5171 imp->overloadedMethodF(longArg); |
5076 } | 5172 } |
5077 | 5173 |
5078 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) | 5174 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>&
info) |
5079 { | 5175 { |
5080 if (UNLIKELY(info.Length() < 1)) { | 5176 if (UNLIKELY(info.Length() < 1)) { |
5081 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); | 5177 throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "
TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), inf
o.GetIsolate()); |
5082 return; | 5178 return; |
5083 } | 5179 } |
5084 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5180 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5157 } | 5253 } |
5158 | 5254 |
5159 static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) | 5255 static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) |
5160 { | 5256 { |
5161 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5257 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5162 imp->overloadedPerWorldBindingsMethod(); | 5258 imp->overloadedPerWorldBindingsMethod(); |
5163 } | 5259 } |
5164 | 5260 |
5165 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 5261 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
5166 { | 5262 { |
| 5263 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP
erWorldBindingsMethod", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5167 if (UNLIKELY(info.Length() < 1)) { | 5264 if (UNLIKELY(info.Length() < 1)) { |
5168 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 5265 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5266 exceptionState.throwIfNeeded(); |
5169 return; | 5267 return; |
5170 } | 5268 } |
5171 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5269 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5172 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5270 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
5173 imp->overloadedPerWorldBindingsMethod(longArg); | 5271 imp->overloadedPerWorldBindingsMethod(longArg); |
5174 } | 5272 } |
5175 | 5273 |
5176 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) | 5274 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInf
o<v8::Value>& info) |
5177 { | 5275 { |
5178 if (((info.Length() == 0))) { | 5276 if (((info.Length() == 0))) { |
5179 overloadedPerWorldBindingsMethod1Method(info); | 5277 overloadedPerWorldBindingsMethod1Method(info); |
5180 return; | 5278 return; |
5181 } | 5279 } |
5182 if (((info.Length() == 1))) { | 5280 if (((info.Length() == 1))) { |
5183 overloadedPerWorldBindingsMethod2Method(info); | 5281 overloadedPerWorldBindingsMethod2Method(info); |
5184 return; | 5282 return; |
5185 } | 5283 } |
5186 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBinding
sMethod", "TestObjectPython", "No function was found that matched the signature
provided."), info.GetIsolate()); | 5284 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBinding
sMethod", "TestObjectPython", "No function was found that matched the signature
provided."), info.GetIsolate()); |
5187 } | 5285 } |
5188 | 5286 |
5189 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 5287 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
5190 { | 5288 { |
5191 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5289 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5192 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethod(info); | 5290 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethod(info); |
5193 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5291 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5194 } | 5292 } |
5195 | 5293 |
5196 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) | 5294 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::Functi
onCallbackInfo<v8::Value>& info) |
5197 { | 5295 { |
| 5296 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedP
erWorldBindingsMethod", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5198 if (UNLIKELY(info.Length() < 1)) { | 5297 if (UNLIKELY(info.Length() < 1)) { |
5199 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBin
dingsMethod", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.
Length())), info.GetIsolate()); | 5298 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5299 exceptionState.throwIfNeeded(); |
5200 return; | 5300 return; |
5201 } | 5301 } |
5202 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5302 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5203 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5303 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
5204 imp->overloadedPerWorldBindingsMethod(longArg); | 5304 imp->overloadedPerWorldBindingsMethod(longArg); |
5205 } | 5305 } |
5206 | 5306 |
5207 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio
nCallbackInfo<v8::Value>& info) | 5307 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::Functio
nCallbackInfo<v8::Value>& info) |
5208 { | 5308 { |
5209 if (((info.Length() == 0))) { | 5309 if (((info.Length() == 0))) { |
5210 overloadedPerWorldBindingsMethod1MethodForMainWorld(info); | 5310 overloadedPerWorldBindingsMethod1MethodForMainWorld(info); |
5211 return; | 5311 return; |
5212 } | 5312 } |
5213 if (((info.Length() == 1))) { | 5313 if (((info.Length() == 1))) { |
5214 overloadedPerWorldBindingsMethod2MethodForMainWorld(info); | 5314 overloadedPerWorldBindingsMethod2MethodForMainWorld(info); |
5215 return; | 5315 return; |
5216 } | 5316 } |
5217 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBinding
sMethod", "TestObjectPython", "No function was found that matched the signature
provided."), info.GetIsolate()); | 5317 throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBinding
sMethod", "TestObjectPython", "No function was found that matched the signature
provided."), info.GetIsolate()); |
5218 } | 5318 } |
5219 | 5319 |
5220 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8:
:FunctionCallbackInfo<v8::Value>& info) | 5320 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8:
:FunctionCallbackInfo<v8::Value>& info) |
5221 { | 5321 { |
5222 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5322 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5223 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodForMainWor
ld(info); | 5323 TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodForMainWor
ld(info); |
5224 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5324 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5225 } | 5325 } |
5226 | 5326 |
5227 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 5327 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
5228 { | 5328 { |
| 5329 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS
taticMethod", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5229 if (UNLIKELY(info.Length() < 1)) { | 5330 if (UNLIKELY(info.Length() < 1)) { |
5230 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length()))
, info.GetIsolate()); | 5331 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5332 exceptionState.throwIfNeeded(); |
5231 return; | 5333 return; |
5232 } | 5334 } |
5233 V8TRYCATCH_VOID(int, longArg, toInt32(info[0])); | 5335 V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), ex
ceptionState); |
5234 TestObjectPython::overloadedStaticMethod(longArg); | 5336 TestObjectPython::overloadedStaticMethod(longArg); |
5235 } | 5337 } |
5236 | 5338 |
5237 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) | 5339 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Val
ue>& info) |
5238 { | 5340 { |
| 5341 ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedS
taticMethod", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5239 if (UNLIKELY(info.Length() < 2)) { | 5342 if (UNLIKELY(info.Length() < 2)) { |
5240 throwTypeError(ExceptionMessages::failedToExecute("overloadedStaticMetho
d", "TestObjectPython", ExceptionMessages::notEnoughArguments(2, info.Length()))
, info.GetIsolate()); | 5343 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, i
nfo.Length())); |
| 5344 exceptionState.throwIfNeeded(); |
5241 return; | 5345 return; |
5242 } | 5346 } |
5243 V8TRYCATCH_VOID(int, longArg1, toInt32(info[0])); | 5347 V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), e
xceptionState); |
5244 V8TRYCATCH_VOID(int, longArg2, toInt32(info[1])); | 5348 V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), e
xceptionState); |
5245 TestObjectPython::overloadedStaticMethod(longArg1, longArg2); | 5349 TestObjectPython::overloadedStaticMethod(longArg1, longArg2); |
5246 } | 5350 } |
5247 | 5351 |
5248 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) | 5352 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Valu
e>& info) |
5249 { | 5353 { |
5250 if (((info.Length() == 1))) { | 5354 if (((info.Length() == 1))) { |
5251 overloadedStaticMethod1Method(info); | 5355 overloadedStaticMethod1Method(info); |
5252 return; | 5356 return; |
5253 } | 5357 } |
5254 if (((info.Length() == 2))) { | 5358 if (((info.Length() == 2))) { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5323 | 5427 |
5324 static void removeEventListenerMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) | 5428 static void removeEventListenerMethodCallback(const v8::FunctionCallbackInfo<v8:
:Value>& info) |
5325 { | 5429 { |
5326 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5430 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5327 TestObjectPythonV8Internal::removeEventListenerMethod(info); | 5431 TestObjectPythonV8Internal::removeEventListenerMethod(info); |
5328 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5432 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5329 } | 5433 } |
5330 | 5434 |
5331 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) | 5435 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo
<v8::Value>& info) |
5332 { | 5436 { |
| 5437 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC
lampUnsignedShortArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5333 if (UNLIKELY(info.Length() < 1)) { | 5438 if (UNLIKELY(info.Length() < 1)) { |
5334 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edShortArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.L
ength())), info.GetIsolate()); | 5439 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5440 exceptionState.throwIfNeeded(); |
5335 return; | 5441 return; |
5336 } | 5442 } |
5337 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5443 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5338 unsigned clampUnsignedShortArg = 0; | 5444 unsigned clampUnsignedShortArg = 0; |
5339 V8TRYCATCH_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberVal
ue()); | 5445 V8TRYCATCH_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberVal
ue()); |
5340 if (!std::isnan(clampUnsignedShortArgNativeValue)) | 5446 if (!std::isnan(clampUnsignedShortArgNativeValue)) |
5341 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNat
iveValue); | 5447 clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNat
iveValue); |
5342 imp->voidMethodClampUnsignedShortArg(clampUnsignedShortArg); | 5448 imp->voidMethodClampUnsignedShortArg(clampUnsignedShortArg); |
5343 } | 5449 } |
5344 | 5450 |
5345 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) | 5451 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCall
backInfo<v8::Value>& info) |
5346 { | 5452 { |
5347 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5453 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5348 TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethod(info); | 5454 TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethod(info); |
5349 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5455 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5350 } | 5456 } |
5351 | 5457 |
5352 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) | 5458 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<
v8::Value>& info) |
5353 { | 5459 { |
| 5460 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodC
lampUnsignedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5354 if (UNLIKELY(info.Length() < 1)) { | 5461 if (UNLIKELY(info.Length() < 1)) { |
5355 throwTypeError(ExceptionMessages::failedToExecute("voidMethodClampUnsign
edLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Le
ngth())), info.GetIsolate()); | 5462 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5463 exceptionState.throwIfNeeded(); |
5356 return; | 5464 return; |
5357 } | 5465 } |
5358 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5466 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5359 unsigned clampUnsignedLongArg = 0; | 5467 unsigned clampUnsignedLongArg = 0; |
5360 V8TRYCATCH_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValu
e()); | 5468 V8TRYCATCH_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValu
e()); |
5361 if (!std::isnan(clampUnsignedLongArgNativeValue)) | 5469 if (!std::isnan(clampUnsignedLongArgNativeValue)) |
5362 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNative
Value); | 5470 clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNative
Value); |
5363 imp->voidMethodClampUnsignedLongArg(clampUnsignedLongArg); | 5471 imp->voidMethodClampUnsignedLongArg(clampUnsignedLongArg); |
5364 } | 5472 } |
5365 | 5473 |
(...skipping 13 matching lines...) Expand all Loading... |
5379 | 5487 |
5380 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) | 5488 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const
v8::FunctionCallbackInfo<v8::Value>& info) |
5381 { | 5489 { |
5382 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5490 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5383 TestObjectPythonV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgM
ethod(info); | 5491 TestObjectPythonV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgM
ethod(info); |
5384 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5492 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5385 } | 5493 } |
5386 | 5494 |
5387 static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackIn
fo<v8::Value>& info) | 5495 static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackIn
fo<v8::Value>& info) |
5388 { | 5496 { |
| 5497 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodD
efaultUndefinedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5389 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5498 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5390 V8TRYCATCH_VOID(int, defaultUndefinedLongArg, toInt32(info[0])); | 5499 V8TRYCATCH_EXCEPTION_VOID(int, defaultUndefinedLongArg, toInt32(info[0], exc
eptionState), exceptionState); |
5391 imp->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg); | 5500 imp->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg); |
5392 } | 5501 } |
5393 | 5502 |
5394 static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCa
llbackInfo<v8::Value>& info) | 5503 static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCa
llbackInfo<v8::Value>& info) |
5395 { | 5504 { |
5396 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5505 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5397 TestObjectPythonV8Internal::voidMethodDefaultUndefinedLongArgMethod(info); | 5506 TestObjectPythonV8Internal::voidMethodDefaultUndefinedLongArgMethod(info); |
5398 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5507 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5399 } | 5508 } |
5400 | 5509 |
(...skipping 20 matching lines...) Expand all Loading... |
5421 | 5530 |
5422 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) | 5531 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::Functio
nCallbackInfo<v8::Value>& info) |
5423 { | 5532 { |
5424 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5533 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5425 TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethod(info)
; | 5534 TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethod(info)
; |
5426 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5535 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5427 } | 5536 } |
5428 | 5537 |
5429 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) | 5538 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v
8::Value>& info) |
5430 { | 5539 { |
| 5540 ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodE
nforceRangeLongArg", "TestObjectPython", info.Holder(), info.GetIsolate()); |
5431 if (UNLIKELY(info.Length() < 1)) { | 5541 if (UNLIKELY(info.Length() < 1)) { |
5432 throwTypeError(ExceptionMessages::failedToExecute("voidMethodEnforceRang
eLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Len
gth())), info.GetIsolate()); | 5542 exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, i
nfo.Length())); |
| 5543 exceptionState.throwIfNeeded(); |
5433 return; | 5544 return; |
5434 } | 5545 } |
5435 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 5546 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
5436 V8TRYCATCH_WITH_TYPECHECK_VOID(int, enforceRangeLongArg, toInt32(info[0], En
forceRange, ok), info.GetIsolate()); | 5547 V8TRYCATCH_EXCEPTION_VOID(int, enforceRangeLongArg, toInt32(info[0], Enforce
Range, exceptionState), exceptionState); |
5437 imp->voidMethodEnforceRangeLongArg(enforceRangeLongArg); | 5548 imp->voidMethodEnforceRangeLongArg(enforceRangeLongArg); |
5438 } | 5549 } |
5439 | 5550 |
5440 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) | 5551 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallba
ckInfo<v8::Value>& info) |
5441 { | 5552 { |
5442 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 5553 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
5443 TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethod(info); | 5554 TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethod(info); |
5444 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 5555 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
5445 } | 5556 } |
5446 | 5557 |
(...skipping 552 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5999 static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCal
lbackInfo<v8::Value>& info) | 6110 static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCal
lbackInfo<v8::Value>& info) |
6000 { | 6111 { |
6001 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep
tionVoidMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsola
te()); | 6112 ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExcep
tionVoidMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsola
te()); |
6002 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); | 6113 TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder()); |
6003 if (UNLIKELY(info.Length() <= 0)) { | 6114 if (UNLIKELY(info.Length() <= 0)) { |
6004 imp->raisesExceptionVoidMethodOptionalLongArg(exceptionState); | 6115 imp->raisesExceptionVoidMethodOptionalLongArg(exceptionState); |
6005 if (exceptionState.throwIfNeeded()) | 6116 if (exceptionState.throwIfNeeded()) |
6006 return; | 6117 return; |
6007 return; | 6118 return; |
6008 } | 6119 } |
6009 V8TRYCATCH_VOID(int, optionalLongArg, toInt32(info[0])); | 6120 V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionSt
ate), exceptionState); |
6010 imp->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionStat
e); | 6121 imp->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionStat
e); |
6011 if (exceptionState.throwIfNeeded()) | 6122 if (exceptionState.throwIfNeeded()) |
6012 return; | 6123 return; |
6013 } | 6124 } |
6014 | 6125 |
6015 static void raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::Fun
ctionCallbackInfo<v8::Value>& info) | 6126 static void raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::Fun
ctionCallbackInfo<v8::Value>& info) |
6016 { | 6127 { |
6017 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); | 6128 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); |
6018 TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(i
nfo); | 6129 TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(i
nfo); |
6019 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); | 6130 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); |
(...skipping 561 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6581 fromInternalPointer(object)->deref(); | 6692 fromInternalPointer(object)->deref(); |
6582 } | 6693 } |
6583 | 6694 |
6584 template<> | 6695 template<> |
6585 v8::Handle<v8::Value> toV8NoInline(TestObjectPython* impl, v8::Handle<v8::Object
> creationContext, v8::Isolate* isolate) | 6696 v8::Handle<v8::Value> toV8NoInline(TestObjectPython* impl, v8::Handle<v8::Object
> creationContext, v8::Isolate* isolate) |
6586 { | 6697 { |
6587 return toV8(impl, creationContext, isolate); | 6698 return toV8(impl, creationContext, isolate); |
6588 } | 6699 } |
6589 | 6700 |
6590 } // namespace WebCore | 6701 } // namespace WebCore |
OLD | NEW |