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