OLD | NEW |
1 /* | 1 /* |
2 This file is part of the Blink open source project. | 2 This file is part of the Blink open source project. |
3 This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY! | 3 This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY! |
4 | 4 |
5 This library is free software; you can redistribute it and/or | 5 This library is free software; you can redistribute it and/or |
6 modify it under the terms of the GNU Library General Public | 6 modify it under the terms of the GNU Library General Public |
7 License as published by the Free Software Foundation; either | 7 License as published by the Free Software Foundation; either |
8 version 2 of the License, or (at your option) any later version. | 8 version 2 of the License, or (at your option) any later version. |
9 | 9 |
10 This library is distributed in the hope that it will be useful, | 10 This library is distributed in the hope that it will be useful, |
(...skipping 2310 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2321 static v8::Handle<v8::Value> voidMethodMethodCallback(const v8::Arguments& args) | 2321 static v8::Handle<v8::Value> voidMethodMethodCallback(const v8::Arguments& args) |
2322 { | 2322 { |
2323 return TestObjV8Internal::voidMethodMethod(args); | 2323 return TestObjV8Internal::voidMethodMethod(args); |
2324 } | 2324 } |
2325 | 2325 |
2326 static v8::Handle<v8::Value> voidMethodWithArgsMethod(const v8::Arguments& args) | 2326 static v8::Handle<v8::Value> voidMethodWithArgsMethod(const v8::Arguments& args) |
2327 { | 2327 { |
2328 if (args.Length() < 3) | 2328 if (args.Length() < 3) |
2329 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2329 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2330 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2330 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2331 ExceptionCode ec = 0; | |
2332 V8TRYCATCH(int, longArg, toInt32(args[0])); | 2331 V8TRYCATCH(int, longArg, toInt32(args[0])); |
2333 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); | 2332 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); |
2334 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); | 2333 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); |
2335 imp->voidMethodWithArgs(longArg, strArg, objArg); | 2334 imp->voidMethodWithArgs(longArg, strArg, objArg); |
2336 return v8Undefined(); | 2335 return v8Undefined(); |
2337 } | 2336 } |
2338 | 2337 |
2339 static v8::Handle<v8::Value> voidMethodWithArgsMethodCallback(const v8::Argument
s& args) | 2338 static v8::Handle<v8::Value> voidMethodWithArgsMethodCallback(const v8::Argument
s& args) |
2340 { | 2339 { |
2341 return TestObjV8Internal::voidMethodWithArgsMethod(args); | 2340 return TestObjV8Internal::voidMethodWithArgsMethod(args); |
2342 } | 2341 } |
2343 | 2342 |
2344 static v8::Handle<v8::Value> longMethodMethod(const v8::Arguments& args) | 2343 static v8::Handle<v8::Value> longMethodMethod(const v8::Arguments& args) |
2345 { | 2344 { |
2346 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2345 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2347 return v8Integer(imp->longMethod(), args.GetIsolate()); | 2346 return v8Integer(imp->longMethod(), args.GetIsolate()); |
2348 } | 2347 } |
2349 | 2348 |
2350 static v8::Handle<v8::Value> longMethodMethodCallback(const v8::Arguments& args) | 2349 static v8::Handle<v8::Value> longMethodMethodCallback(const v8::Arguments& args) |
2351 { | 2350 { |
2352 return TestObjV8Internal::longMethodMethod(args); | 2351 return TestObjV8Internal::longMethodMethod(args); |
2353 } | 2352 } |
2354 | 2353 |
2355 static v8::Handle<v8::Value> longMethodWithArgsMethod(const v8::Arguments& args) | 2354 static v8::Handle<v8::Value> longMethodWithArgsMethod(const v8::Arguments& args) |
2356 { | 2355 { |
2357 if (args.Length() < 3) | 2356 if (args.Length() < 3) |
2358 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2357 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2359 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2358 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2360 ExceptionCode ec = 0; | |
2361 V8TRYCATCH(int, longArg, toInt32(args[0])); | 2359 V8TRYCATCH(int, longArg, toInt32(args[0])); |
2362 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); | 2360 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); |
2363 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); | 2361 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); |
2364 return v8Integer(imp->longMethodWithArgs(longArg, strArg, objArg), args.GetI
solate()); | 2362 return v8Integer(imp->longMethodWithArgs(longArg, strArg, objArg), args.GetI
solate()); |
2365 } | 2363 } |
2366 | 2364 |
2367 static v8::Handle<v8::Value> longMethodWithArgsMethodCallback(const v8::Argument
s& args) | 2365 static v8::Handle<v8::Value> longMethodWithArgsMethodCallback(const v8::Argument
s& args) |
2368 { | 2366 { |
2369 return TestObjV8Internal::longMethodWithArgsMethod(args); | 2367 return TestObjV8Internal::longMethodWithArgsMethod(args); |
2370 } | 2368 } |
2371 | 2369 |
2372 static v8::Handle<v8::Value> objMethodMethod(const v8::Arguments& args) | 2370 static v8::Handle<v8::Value> objMethodMethod(const v8::Arguments& args) |
2373 { | 2371 { |
2374 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2372 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2375 return toV8(imp->objMethod(), args.Holder(), args.GetIsolate()); | 2373 return toV8(imp->objMethod(), args.Holder(), args.GetIsolate()); |
2376 } | 2374 } |
2377 | 2375 |
2378 static v8::Handle<v8::Value> objMethodMethodCallback(const v8::Arguments& args) | 2376 static v8::Handle<v8::Value> objMethodMethodCallback(const v8::Arguments& args) |
2379 { | 2377 { |
2380 UseCounter::count(activeDOMWindow(), UseCounter::TestFeature); | 2378 UseCounter::count(activeDOMWindow(), UseCounter::TestFeature); |
2381 return TestObjV8Internal::objMethodMethod(args); | 2379 return TestObjV8Internal::objMethodMethod(args); |
2382 } | 2380 } |
2383 | 2381 |
2384 static v8::Handle<v8::Value> objMethodWithArgsMethod(const v8::Arguments& args) | 2382 static v8::Handle<v8::Value> objMethodWithArgsMethod(const v8::Arguments& args) |
2385 { | 2383 { |
2386 if (args.Length() < 3) | 2384 if (args.Length() < 3) |
2387 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2385 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2388 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2386 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2389 ExceptionCode ec = 0; | |
2390 V8TRYCATCH(int, longArg, toInt32(args[0])); | 2387 V8TRYCATCH(int, longArg, toInt32(args[0])); |
2391 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); | 2388 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); |
2392 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); | 2389 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[2], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[2])) : 0); |
2393 return toV8(imp->objMethodWithArgs(longArg, strArg, objArg), args.Holder(),
args.GetIsolate()); | 2390 return toV8(imp->objMethodWithArgs(longArg, strArg, objArg), args.Holder(),
args.GetIsolate()); |
2394 } | 2391 } |
2395 | 2392 |
2396 static v8::Handle<v8::Value> objMethodWithArgsMethodCallback(const v8::Arguments
& args) | 2393 static v8::Handle<v8::Value> objMethodWithArgsMethodCallback(const v8::Arguments
& args) |
2397 { | 2394 { |
2398 return TestObjV8Internal::objMethodWithArgsMethod(args); | 2395 return TestObjV8Internal::objMethodWithArgsMethod(args); |
2399 } | 2396 } |
2400 | 2397 |
2401 static v8::Handle<v8::Value> methodWithSequenceArgMethod(const v8::Arguments& ar
gs) | 2398 static v8::Handle<v8::Value> methodWithSequenceArgMethod(const v8::Arguments& ar
gs) |
2402 { | 2399 { |
2403 if (args.Length() < 1) | 2400 if (args.Length() < 1) |
2404 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2401 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2405 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2402 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2406 ExceptionCode ec = 0; | |
2407 V8TRYCATCH(Vector<RefPtr<ScriptProfile> >, sequenceArg, (toRefPtrNativeArray
<ScriptProfile, V8ScriptProfile>(args[0], args.GetIsolate()))); | 2403 V8TRYCATCH(Vector<RefPtr<ScriptProfile> >, sequenceArg, (toRefPtrNativeArray
<ScriptProfile, V8ScriptProfile>(args[0], args.GetIsolate()))); |
2408 imp->methodWithSequenceArg(sequenceArg); | 2404 imp->methodWithSequenceArg(sequenceArg); |
2409 return v8Undefined(); | 2405 return v8Undefined(); |
2410 } | 2406 } |
2411 | 2407 |
2412 static v8::Handle<v8::Value> methodWithSequenceArgMethodCallback(const v8::Argum
ents& args) | 2408 static v8::Handle<v8::Value> methodWithSequenceArgMethodCallback(const v8::Argum
ents& args) |
2413 { | 2409 { |
2414 return TestObjV8Internal::methodWithSequenceArgMethod(args); | 2410 return TestObjV8Internal::methodWithSequenceArgMethod(args); |
2415 } | 2411 } |
2416 | 2412 |
2417 static v8::Handle<v8::Value> methodReturningSequenceMethod(const v8::Arguments&
args) | 2413 static v8::Handle<v8::Value> methodReturningSequenceMethod(const v8::Arguments&
args) |
2418 { | 2414 { |
2419 if (args.Length() < 1) | 2415 if (args.Length() < 1) |
2420 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2416 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2421 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2417 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2422 ExceptionCode ec = 0; | |
2423 V8TRYCATCH(int, longArg, toInt32(args[0])); | 2418 V8TRYCATCH(int, longArg, toInt32(args[0])); |
2424 return v8Array(imp->methodReturningSequence(longArg), args.GetIsolate()); | 2419 return v8Array(imp->methodReturningSequence(longArg), args.GetIsolate()); |
2425 } | 2420 } |
2426 | 2421 |
2427 static v8::Handle<v8::Value> methodReturningSequenceMethodCallback(const v8::Arg
uments& args) | 2422 static v8::Handle<v8::Value> methodReturningSequenceMethodCallback(const v8::Arg
uments& args) |
2428 { | 2423 { |
2429 return TestObjV8Internal::methodReturningSequenceMethod(args); | 2424 return TestObjV8Internal::methodReturningSequenceMethod(args); |
2430 } | 2425 } |
2431 | 2426 |
2432 static v8::Handle<v8::Value> methodWithEnumArgMethod(const v8::Arguments& args) | 2427 static v8::Handle<v8::Value> methodWithEnumArgMethod(const v8::Arguments& args) |
2433 { | 2428 { |
2434 if (args.Length() < 1) | 2429 if (args.Length() < 1) |
2435 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2430 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2436 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2431 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2437 ExceptionCode ec = 0; | |
2438 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, enumArg, args[0]); | 2432 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, enumArg, args[0]); |
2439 String string = enumArg; | 2433 String string = enumArg; |
2440 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || st
ring == "EnumValue3")) | 2434 if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || st
ring == "EnumValue3")) |
2441 return throwTypeError(0, args.GetIsolate()); | 2435 return throwTypeError(0, args.GetIsolate()); |
2442 imp->methodWithEnumArg(enumArg); | 2436 imp->methodWithEnumArg(enumArg); |
2443 return v8Undefined(); | 2437 return v8Undefined(); |
2444 } | 2438 } |
2445 | 2439 |
2446 static v8::Handle<v8::Value> methodWithEnumArgMethodCallback(const v8::Arguments
& args) | 2440 static v8::Handle<v8::Value> methodWithEnumArgMethodCallback(const v8::Arguments
& args) |
2447 { | 2441 { |
(...skipping 17 matching lines...) Expand all Loading... |
2465 static v8::Handle<v8::Value> methodThatRequiresAllArgsAndThrowsMethodCallback(co
nst v8::Arguments& args) | 2459 static v8::Handle<v8::Value> methodThatRequiresAllArgsAndThrowsMethodCallback(co
nst v8::Arguments& args) |
2466 { | 2460 { |
2467 return TestObjV8Internal::methodThatRequiresAllArgsAndThrowsMethod(args); | 2461 return TestObjV8Internal::methodThatRequiresAllArgsAndThrowsMethod(args); |
2468 } | 2462 } |
2469 | 2463 |
2470 static v8::Handle<v8::Value> serializedValueMethod(const v8::Arguments& args) | 2464 static v8::Handle<v8::Value> serializedValueMethod(const v8::Arguments& args) |
2471 { | 2465 { |
2472 if (args.Length() < 1) | 2466 if (args.Length() < 1) |
2473 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2467 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2474 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2468 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2475 ExceptionCode ec = 0; | |
2476 bool serializedArgDidThrow = false; | 2469 bool serializedArgDidThrow = false; |
2477 RefPtr<SerializedScriptValue> serializedArg = SerializedScriptValue::create(
args[0], 0, 0, serializedArgDidThrow, args.GetIsolate()); | 2470 RefPtr<SerializedScriptValue> serializedArg = SerializedScriptValue::create(
args[0], 0, 0, serializedArgDidThrow, args.GetIsolate()); |
2478 if (serializedArgDidThrow) | 2471 if (serializedArgDidThrow) |
2479 return v8Undefined(); | 2472 return v8Undefined(); |
2480 imp->serializedValue(serializedArg); | 2473 imp->serializedValue(serializedArg); |
2481 return v8Undefined(); | 2474 return v8Undefined(); |
2482 } | 2475 } |
2483 | 2476 |
2484 static v8::Handle<v8::Value> serializedValueMethodCallback(const v8::Arguments&
args) | 2477 static v8::Handle<v8::Value> serializedValueMethodCallback(const v8::Arguments&
args) |
2485 { | 2478 { |
2486 return TestObjV8Internal::serializedValueMethod(args); | 2479 return TestObjV8Internal::serializedValueMethod(args); |
2487 } | 2480 } |
2488 | 2481 |
2489 static v8::Handle<v8::Value> optionsObjectMethod(const v8::Arguments& args) | 2482 static v8::Handle<v8::Value> optionsObjectMethod(const v8::Arguments& args) |
2490 { | 2483 { |
2491 if (args.Length() < 1) | 2484 if (args.Length() < 1) |
2492 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2485 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2493 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2486 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2494 ExceptionCode ec = 0; | |
2495 V8TRYCATCH(Dictionary, oo, Dictionary(args[0], args.GetIsolate())); | 2487 V8TRYCATCH(Dictionary, oo, Dictionary(args[0], args.GetIsolate())); |
2496 if (!oo.isUndefinedOrNull() && !oo.isObject()) | 2488 if (!oo.isUndefinedOrNull() && !oo.isObject()) |
2497 return throwTypeError("Not an object.", args.GetIsolate()); | 2489 return throwTypeError("Not an object.", args.GetIsolate()); |
2498 V8TRYCATCH(Dictionary, ooo, Dictionary(args[1], args.GetIsolate())); | 2490 V8TRYCATCH(Dictionary, ooo, Dictionary(args[1], args.GetIsolate())); |
2499 if (!ooo.isUndefinedOrNull() && !ooo.isObject()) | 2491 if (!ooo.isUndefinedOrNull() && !ooo.isObject()) |
2500 return throwTypeError("Not an object.", args.GetIsolate()); | 2492 return throwTypeError("Not an object.", args.GetIsolate()); |
2501 imp->optionsObject(oo, ooo); | 2493 imp->optionsObject(oo, ooo); |
2502 return v8Undefined(); | 2494 return v8Undefined(); |
2503 } | 2495 } |
2504 | 2496 |
(...skipping 228 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2733 } | 2725 } |
2734 | 2726 |
2735 static v8::Handle<v8::Value> withScriptExecutionContextAndScriptStateWithSpacesM
ethodCallback(const v8::Arguments& args) | 2727 static v8::Handle<v8::Value> withScriptExecutionContextAndScriptStateWithSpacesM
ethodCallback(const v8::Arguments& args) |
2736 { | 2728 { |
2737 return TestObjV8Internal::withScriptExecutionContextAndScriptStateWithSpaces
Method(args); | 2729 return TestObjV8Internal::withScriptExecutionContextAndScriptStateWithSpaces
Method(args); |
2738 } | 2730 } |
2739 | 2731 |
2740 static v8::Handle<v8::Value> methodWithOptionalArgMethod(const v8::Arguments& ar
gs) | 2732 static v8::Handle<v8::Value> methodWithOptionalArgMethod(const v8::Arguments& ar
gs) |
2741 { | 2733 { |
2742 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2734 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2743 ExceptionCode ec = 0; | |
2744 if (args.Length() <= 0) { | 2735 if (args.Length() <= 0) { |
2745 imp->methodWithOptionalArg(); | 2736 imp->methodWithOptionalArg(); |
2746 return v8Undefined(); | 2737 return v8Undefined(); |
2747 } | 2738 } |
2748 V8TRYCATCH(int, opt, toInt32(args[0])); | 2739 V8TRYCATCH(int, opt, toInt32(args[0])); |
2749 imp->methodWithOptionalArg(opt); | 2740 imp->methodWithOptionalArg(opt); |
2750 return v8Undefined(); | 2741 return v8Undefined(); |
2751 } | 2742 } |
2752 | 2743 |
2753 static v8::Handle<v8::Value> methodWithOptionalArgMethodCallback(const v8::Argum
ents& args) | 2744 static v8::Handle<v8::Value> methodWithOptionalArgMethodCallback(const v8::Argum
ents& args) |
2754 { | 2745 { |
2755 return TestObjV8Internal::methodWithOptionalArgMethod(args); | 2746 return TestObjV8Internal::methodWithOptionalArgMethod(args); |
2756 } | 2747 } |
2757 | 2748 |
2758 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethod(const
v8::Arguments& args) | 2749 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethod(const
v8::Arguments& args) |
2759 { | 2750 { |
2760 if (args.Length() < 1) | 2751 if (args.Length() < 1) |
2761 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2752 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2762 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2753 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2763 ExceptionCode ec = 0; | |
2764 V8TRYCATCH(int, nonOpt, toInt32(args[0])); | 2754 V8TRYCATCH(int, nonOpt, toInt32(args[0])); |
2765 if (args.Length() <= 1) { | 2755 if (args.Length() <= 1) { |
2766 imp->methodWithNonOptionalArgAndOptionalArg(nonOpt); | 2756 imp->methodWithNonOptionalArgAndOptionalArg(nonOpt); |
2767 return v8Undefined(); | 2757 return v8Undefined(); |
2768 } | 2758 } |
2769 V8TRYCATCH(int, opt, toInt32(args[1])); | 2759 V8TRYCATCH(int, opt, toInt32(args[1])); |
2770 imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt); | 2760 imp->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt); |
2771 return v8Undefined(); | 2761 return v8Undefined(); |
2772 } | 2762 } |
2773 | 2763 |
2774 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethodCallbac
k(const v8::Arguments& args) | 2764 static v8::Handle<v8::Value> methodWithNonOptionalArgAndOptionalArgMethodCallbac
k(const v8::Arguments& args) |
2775 { | 2765 { |
2776 return TestObjV8Internal::methodWithNonOptionalArgAndOptionalArgMethod(args)
; | 2766 return TestObjV8Internal::methodWithNonOptionalArgAndOptionalArgMethod(args)
; |
2777 } | 2767 } |
2778 | 2768 |
2779 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethod(co
nst v8::Arguments& args) | 2769 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethod(co
nst v8::Arguments& args) |
2780 { | 2770 { |
2781 if (args.Length() < 1) | 2771 if (args.Length() < 1) |
2782 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2772 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2783 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2773 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2784 ExceptionCode ec = 0; | |
2785 V8TRYCATCH(int, nonOpt, toInt32(args[0])); | 2774 V8TRYCATCH(int, nonOpt, toInt32(args[0])); |
2786 if (args.Length() <= 1) { | 2775 if (args.Length() <= 1) { |
2787 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt); | 2776 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt); |
2788 return v8Undefined(); | 2777 return v8Undefined(); |
2789 } | 2778 } |
2790 V8TRYCATCH(int, opt1, toInt32(args[1])); | 2779 V8TRYCATCH(int, opt1, toInt32(args[1])); |
2791 if (args.Length() <= 2) { | 2780 if (args.Length() <= 2) { |
2792 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1); | 2781 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1); |
2793 return v8Undefined(); | 2782 return v8Undefined(); |
2794 } | 2783 } |
2795 V8TRYCATCH(int, opt2, toInt32(args[2])); | 2784 V8TRYCATCH(int, opt2, toInt32(args[2])); |
2796 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2); | 2785 imp->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2); |
2797 return v8Undefined(); | 2786 return v8Undefined(); |
2798 } | 2787 } |
2799 | 2788 |
2800 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethodCal
lback(const v8::Arguments& args) | 2789 static v8::Handle<v8::Value> methodWithNonOptionalArgAndTwoOptionalArgsMethodCal
lback(const v8::Arguments& args) |
2801 { | 2790 { |
2802 return TestObjV8Internal::methodWithNonOptionalArgAndTwoOptionalArgsMethod(a
rgs); | 2791 return TestObjV8Internal::methodWithNonOptionalArgAndTwoOptionalArgsMethod(a
rgs); |
2803 } | 2792 } |
2804 | 2793 |
2805 static v8::Handle<v8::Value> methodWithOptionalStringMethod(const v8::Arguments&
args) | 2794 static v8::Handle<v8::Value> methodWithOptionalStringMethod(const v8::Arguments&
args) |
2806 { | 2795 { |
2807 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2796 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2808 ExceptionCode ec = 0; | |
2809 if (args.Length() <= 0) { | 2797 if (args.Length() <= 0) { |
2810 imp->methodWithOptionalString(); | 2798 imp->methodWithOptionalString(); |
2811 return v8Undefined(); | 2799 return v8Undefined(); |
2812 } | 2800 } |
2813 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]); | 2801 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]); |
2814 imp->methodWithOptionalString(str); | 2802 imp->methodWithOptionalString(str); |
2815 return v8Undefined(); | 2803 return v8Undefined(); |
2816 } | 2804 } |
2817 | 2805 |
2818 static v8::Handle<v8::Value> methodWithOptionalStringMethodCallback(const v8::Ar
guments& args) | 2806 static v8::Handle<v8::Value> methodWithOptionalStringMethodCallback(const v8::Ar
guments& args) |
2819 { | 2807 { |
2820 return TestObjV8Internal::methodWithOptionalStringMethod(args); | 2808 return TestObjV8Internal::methodWithOptionalStringMethod(args); |
2821 } | 2809 } |
2822 | 2810 |
2823 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethod(const v8:
:Arguments& args) | 2811 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethod(const v8:
:Arguments& args) |
2824 { | 2812 { |
2825 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2813 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2826 ExceptionCode ec = 0; | |
2827 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]); | 2814 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, args[0]); |
2828 imp->methodWithOptionalStringIsUndefined(str); | 2815 imp->methodWithOptionalStringIsUndefined(str); |
2829 return v8Undefined(); | 2816 return v8Undefined(); |
2830 } | 2817 } |
2831 | 2818 |
2832 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethodCallback(c
onst v8::Arguments& args) | 2819 static v8::Handle<v8::Value> methodWithOptionalStringIsUndefinedMethodCallback(c
onst v8::Arguments& args) |
2833 { | 2820 { |
2834 return TestObjV8Internal::methodWithOptionalStringIsUndefinedMethod(args); | 2821 return TestObjV8Internal::methodWithOptionalStringIsUndefinedMethod(args); |
2835 } | 2822 } |
2836 | 2823 |
2837 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethod(const v8
::Arguments& args) | 2824 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethod(const v8
::Arguments& args) |
2838 { | 2825 { |
2839 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2826 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2840 ExceptionCode ec = 0; | |
2841 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, argumentOrNull(args
, 0)); | 2827 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, str, argumentOrNull(args
, 0)); |
2842 imp->methodWithOptionalStringIsNullString(str); | 2828 imp->methodWithOptionalStringIsNullString(str); |
2843 return v8Undefined(); | 2829 return v8Undefined(); |
2844 } | 2830 } |
2845 | 2831 |
2846 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethodCallback(
const v8::Arguments& args) | 2832 static v8::Handle<v8::Value> methodWithOptionalStringIsNullStringMethodCallback(
const v8::Arguments& args) |
2847 { | 2833 { |
2848 return TestObjV8Internal::methodWithOptionalStringIsNullStringMethod(args); | 2834 return TestObjV8Internal::methodWithOptionalStringIsNullStringMethod(args); |
2849 } | 2835 } |
2850 | 2836 |
(...skipping 12 matching lines...) Expand all Loading... |
2863 static v8::Handle<v8::Value> methodWithCallbackArgMethodCallback(const v8::Argum
ents& args) | 2849 static v8::Handle<v8::Value> methodWithCallbackArgMethodCallback(const v8::Argum
ents& args) |
2864 { | 2850 { |
2865 return TestObjV8Internal::methodWithCallbackArgMethod(args); | 2851 return TestObjV8Internal::methodWithCallbackArgMethod(args); |
2866 } | 2852 } |
2867 | 2853 |
2868 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethod(const
v8::Arguments& args) | 2854 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethod(const
v8::Arguments& args) |
2869 { | 2855 { |
2870 if (args.Length() < 2) | 2856 if (args.Length() < 2) |
2871 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2857 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2872 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2858 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2873 ExceptionCode ec = 0; | |
2874 V8TRYCATCH(int, nonCallback, toInt32(args[0])); | 2859 V8TRYCATCH(int, nonCallback, toInt32(args[0])); |
2875 if (args.Length() <= 1 || !args[1]->IsFunction()) | 2860 if (args.Length() <= 1 || !args[1]->IsFunction()) |
2876 return throwTypeError(0, args.GetIsolate()); | 2861 return throwTypeError(0, args.GetIsolate()); |
2877 RefPtr<TestCallback> callback = V8TestCallback::create(args[1], getScriptExe
cutionContext()); | 2862 RefPtr<TestCallback> callback = V8TestCallback::create(args[1], getScriptExe
cutionContext()); |
2878 imp->methodWithNonCallbackArgAndCallbackArg(nonCallback, callback); | 2863 imp->methodWithNonCallbackArgAndCallbackArg(nonCallback, callback); |
2879 return v8Undefined(); | 2864 return v8Undefined(); |
2880 } | 2865 } |
2881 | 2866 |
2882 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethodCallbac
k(const v8::Arguments& args) | 2867 static v8::Handle<v8::Value> methodWithNonCallbackArgAndCallbackArgMethodCallbac
k(const v8::Arguments& args) |
2883 { | 2868 { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2933 static v8::Handle<v8::Value> staticMethodWithCallbackArgMethodCallback(const v8:
:Arguments& args) | 2918 static v8::Handle<v8::Value> staticMethodWithCallbackArgMethodCallback(const v8:
:Arguments& args) |
2934 { | 2919 { |
2935 return TestObjV8Internal::staticMethodWithCallbackArgMethod(args); | 2920 return TestObjV8Internal::staticMethodWithCallbackArgMethod(args); |
2936 } | 2921 } |
2937 | 2922 |
2938 static v8::Handle<v8::Value> methodWithEnforceRangeInt32Method(const v8::Argumen
ts& args) | 2923 static v8::Handle<v8::Value> methodWithEnforceRangeInt32Method(const v8::Argumen
ts& args) |
2939 { | 2924 { |
2940 if (args.Length() < 1) | 2925 if (args.Length() < 1) |
2941 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2926 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2942 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2927 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2943 ExceptionCode ec = 0; | |
2944 V8TRYCATCH_WITH_TYPECHECK(int, value, toInt32(args[0], EnforceRange, ok), ar
gs.GetIsolate()); | 2928 V8TRYCATCH_WITH_TYPECHECK(int, value, toInt32(args[0], EnforceRange, ok), ar
gs.GetIsolate()); |
2945 imp->methodWithEnforceRangeInt32(value); | 2929 imp->methodWithEnforceRangeInt32(value); |
2946 return v8Undefined(); | 2930 return v8Undefined(); |
2947 } | 2931 } |
2948 | 2932 |
2949 static v8::Handle<v8::Value> methodWithEnforceRangeInt32MethodCallback(const v8:
:Arguments& args) | 2933 static v8::Handle<v8::Value> methodWithEnforceRangeInt32MethodCallback(const v8:
:Arguments& args) |
2950 { | 2934 { |
2951 return TestObjV8Internal::methodWithEnforceRangeInt32Method(args); | 2935 return TestObjV8Internal::methodWithEnforceRangeInt32Method(args); |
2952 } | 2936 } |
2953 | 2937 |
2954 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32Method(const v8::Argume
nts& args) | 2938 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32Method(const v8::Argume
nts& args) |
2955 { | 2939 { |
2956 if (args.Length() < 1) | 2940 if (args.Length() < 1) |
2957 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2941 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2958 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2942 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2959 ExceptionCode ec = 0; | |
2960 V8TRYCATCH_WITH_TYPECHECK(unsigned, value, toUInt32(args[0], EnforceRange, o
k), args.GetIsolate()); | 2943 V8TRYCATCH_WITH_TYPECHECK(unsigned, value, toUInt32(args[0], EnforceRange, o
k), args.GetIsolate()); |
2961 imp->methodWithEnforceRangeUInt32(value); | 2944 imp->methodWithEnforceRangeUInt32(value); |
2962 return v8Undefined(); | 2945 return v8Undefined(); |
2963 } | 2946 } |
2964 | 2947 |
2965 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32MethodCallback(const v8
::Arguments& args) | 2948 static v8::Handle<v8::Value> methodWithEnforceRangeUInt32MethodCallback(const v8
::Arguments& args) |
2966 { | 2949 { |
2967 return TestObjV8Internal::methodWithEnforceRangeUInt32Method(args); | 2950 return TestObjV8Internal::methodWithEnforceRangeUInt32Method(args); |
2968 } | 2951 } |
2969 | 2952 |
2970 static v8::Handle<v8::Value> methodWithEnforceRangeInt64Method(const v8::Argumen
ts& args) | 2953 static v8::Handle<v8::Value> methodWithEnforceRangeInt64Method(const v8::Argumen
ts& args) |
2971 { | 2954 { |
2972 if (args.Length() < 1) | 2955 if (args.Length() < 1) |
2973 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2956 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2974 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2957 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2975 ExceptionCode ec = 0; | |
2976 V8TRYCATCH_WITH_TYPECHECK(long long, value, toInt64(args[0], EnforceRange, o
k), args.GetIsolate()); | 2958 V8TRYCATCH_WITH_TYPECHECK(long long, value, toInt64(args[0], EnforceRange, o
k), args.GetIsolate()); |
2977 imp->methodWithEnforceRangeInt64(value); | 2959 imp->methodWithEnforceRangeInt64(value); |
2978 return v8Undefined(); | 2960 return v8Undefined(); |
2979 } | 2961 } |
2980 | 2962 |
2981 static v8::Handle<v8::Value> methodWithEnforceRangeInt64MethodCallback(const v8:
:Arguments& args) | 2963 static v8::Handle<v8::Value> methodWithEnforceRangeInt64MethodCallback(const v8:
:Arguments& args) |
2982 { | 2964 { |
2983 return TestObjV8Internal::methodWithEnforceRangeInt64Method(args); | 2965 return TestObjV8Internal::methodWithEnforceRangeInt64Method(args); |
2984 } | 2966 } |
2985 | 2967 |
2986 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64Method(const v8::Argume
nts& args) | 2968 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64Method(const v8::Argume
nts& args) |
2987 { | 2969 { |
2988 if (args.Length() < 1) | 2970 if (args.Length() < 1) |
2989 return throwNotEnoughArgumentsError(args.GetIsolate()); | 2971 return throwNotEnoughArgumentsError(args.GetIsolate()); |
2990 TestObj* imp = V8TestObject::toNative(args.Holder()); | 2972 TestObj* imp = V8TestObject::toNative(args.Holder()); |
2991 ExceptionCode ec = 0; | |
2992 V8TRYCATCH_WITH_TYPECHECK(unsigned long long, value, toUInt64(args[0], Enfor
ceRange, ok), args.GetIsolate()); | 2973 V8TRYCATCH_WITH_TYPECHECK(unsigned long long, value, toUInt64(args[0], Enfor
ceRange, ok), args.GetIsolate()); |
2993 imp->methodWithEnforceRangeUInt64(value); | 2974 imp->methodWithEnforceRangeUInt64(value); |
2994 return v8Undefined(); | 2975 return v8Undefined(); |
2995 } | 2976 } |
2996 | 2977 |
2997 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64MethodCallback(const v8
::Arguments& args) | 2978 static v8::Handle<v8::Value> methodWithEnforceRangeUInt64MethodCallback(const v8
::Arguments& args) |
2998 { | 2979 { |
2999 return TestObjV8Internal::methodWithEnforceRangeUInt64Method(args); | 2980 return TestObjV8Internal::methodWithEnforceRangeUInt64Method(args); |
3000 } | 2981 } |
3001 | 2982 |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3056 return TestObjV8Internal::conditionalMethod3Method(args); | 3037 return TestObjV8Internal::conditionalMethod3Method(args); |
3057 } | 3038 } |
3058 | 3039 |
3059 #endif // ENABLE(Condition1) || ENABLE(Condition2) | 3040 #endif // ENABLE(Condition1) || ENABLE(Condition2) |
3060 | 3041 |
3061 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args) | 3042 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args) |
3062 { | 3043 { |
3063 if (args.Length() < 2) | 3044 if (args.Length() < 2) |
3064 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3045 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3065 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3046 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3066 ExceptionCode ec = 0; | |
3067 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); | 3047 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); |
3068 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); | 3048 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[1]); |
3069 imp->overloadedMethod(objArg, strArg); | 3049 imp->overloadedMethod(objArg, strArg); |
3070 return v8Undefined(); | 3050 return v8Undefined(); |
3071 } | 3051 } |
3072 | 3052 |
3073 static v8::Handle<v8::Value> overloadedMethod2Method(const v8::Arguments& args) | 3053 static v8::Handle<v8::Value> overloadedMethod2Method(const v8::Arguments& args) |
3074 { | 3054 { |
3075 if (args.Length() < 1) | 3055 if (args.Length() < 1) |
3076 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3056 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3077 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3057 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3078 ExceptionCode ec = 0; | |
3079 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); | 3058 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); |
3080 if (args.Length() <= 1) { | 3059 if (args.Length() <= 1) { |
3081 imp->overloadedMethod(objArg); | 3060 imp->overloadedMethod(objArg); |
3082 return v8Undefined(); | 3061 return v8Undefined(); |
3083 } | 3062 } |
3084 V8TRYCATCH(int, longArg, toInt32(args[1])); | 3063 V8TRYCATCH(int, longArg, toInt32(args[1])); |
3085 imp->overloadedMethod(objArg, longArg); | 3064 imp->overloadedMethod(objArg, longArg); |
3086 return v8Undefined(); | 3065 return v8Undefined(); |
3087 } | 3066 } |
3088 | 3067 |
3089 static v8::Handle<v8::Value> overloadedMethod3Method(const v8::Arguments& args) | 3068 static v8::Handle<v8::Value> overloadedMethod3Method(const v8::Arguments& args) |
3090 { | 3069 { |
3091 if (args.Length() < 1) | 3070 if (args.Length() < 1) |
3092 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3071 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3093 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3072 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3094 ExceptionCode ec = 0; | |
3095 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3073 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3096 imp->overloadedMethod(strArg); | 3074 imp->overloadedMethod(strArg); |
3097 return v8Undefined(); | 3075 return v8Undefined(); |
3098 } | 3076 } |
3099 | 3077 |
3100 static v8::Handle<v8::Value> overloadedMethod4Method(const v8::Arguments& args) | 3078 static v8::Handle<v8::Value> overloadedMethod4Method(const v8::Arguments& args) |
3101 { | 3079 { |
3102 if (args.Length() < 1) | 3080 if (args.Length() < 1) |
3103 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3081 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3104 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3082 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3105 ExceptionCode ec = 0; | |
3106 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3083 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3107 imp->overloadedMethod(longArg); | 3084 imp->overloadedMethod(longArg); |
3108 return v8Undefined(); | 3085 return v8Undefined(); |
3109 } | 3086 } |
3110 | 3087 |
3111 static v8::Handle<v8::Value> overloadedMethod5Method(const v8::Arguments& args) | 3088 static v8::Handle<v8::Value> overloadedMethod5Method(const v8::Arguments& args) |
3112 { | 3089 { |
3113 if (args.Length() < 1) | 3090 if (args.Length() < 1) |
3114 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3091 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3115 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3092 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3116 if (args.Length() <= 0 || !args[0]->IsFunction()) | 3093 if (args.Length() <= 0 || !args[0]->IsFunction()) |
3117 return throwTypeError(0, args.GetIsolate()); | 3094 return throwTypeError(0, args.GetIsolate()); |
3118 RefPtr<TestCallback> callback = V8TestCallback::create(args[0], getScriptExe
cutionContext()); | 3095 RefPtr<TestCallback> callback = V8TestCallback::create(args[0], getScriptExe
cutionContext()); |
3119 imp->overloadedMethod(callback); | 3096 imp->overloadedMethod(callback); |
3120 return v8Undefined(); | 3097 return v8Undefined(); |
3121 } | 3098 } |
3122 | 3099 |
3123 static v8::Handle<v8::Value> overloadedMethod6Method(const v8::Arguments& args) | 3100 static v8::Handle<v8::Value> overloadedMethod6Method(const v8::Arguments& args) |
3124 { | 3101 { |
3125 if (args.Length() < 1) | 3102 if (args.Length() < 1) |
3126 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3103 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3127 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3104 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3128 ExceptionCode ec = 0; | |
3129 V8TRYCATCH(RefPtr<DOMStringList>, listArg, toDOMStringList(args[0], args.Get
Isolate())); | 3105 V8TRYCATCH(RefPtr<DOMStringList>, listArg, toDOMStringList(args[0], args.Get
Isolate())); |
3130 imp->overloadedMethod(listArg); | 3106 imp->overloadedMethod(listArg); |
3131 return v8Undefined(); | 3107 return v8Undefined(); |
3132 } | 3108 } |
3133 | 3109 |
3134 static v8::Handle<v8::Value> overloadedMethod7Method(const v8::Arguments& args) | 3110 static v8::Handle<v8::Value> overloadedMethod7Method(const v8::Arguments& args) |
3135 { | 3111 { |
3136 if (args.Length() < 1) | 3112 if (args.Length() < 1) |
3137 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3113 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3138 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3114 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3139 ExceptionCode ec = 0; | |
3140 V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0])); | 3115 V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0])); |
3141 imp->overloadedMethod(arrayArg); | 3116 imp->overloadedMethod(arrayArg); |
3142 return v8Undefined(); | 3117 return v8Undefined(); |
3143 } | 3118 } |
3144 | 3119 |
3145 static v8::Handle<v8::Value> overloadedMethod8Method(const v8::Arguments& args) | 3120 static v8::Handle<v8::Value> overloadedMethod8Method(const v8::Arguments& args) |
3146 { | 3121 { |
3147 if (args.Length() < 1) | 3122 if (args.Length() < 1) |
3148 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3123 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3149 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3124 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3150 ExceptionCode ec = 0; | |
3151 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); | 3125 V8TRYCATCH(TestObj*, objArg, V8TestObject::HasInstance(args[0], args.GetIsol
ate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Obj
ect>::Cast(args[0])) : 0); |
3152 imp->overloadedMethod(objArg); | 3126 imp->overloadedMethod(objArg); |
3153 return v8Undefined(); | 3127 return v8Undefined(); |
3154 } | 3128 } |
3155 | 3129 |
3156 static v8::Handle<v8::Value> overloadedMethod9Method(const v8::Arguments& args) | 3130 static v8::Handle<v8::Value> overloadedMethod9Method(const v8::Arguments& args) |
3157 { | 3131 { |
3158 if (args.Length() < 1) | 3132 if (args.Length() < 1) |
3159 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3133 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3160 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3134 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3161 ExceptionCode ec = 0; | |
3162 V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0])); | 3135 V8TRYCATCH(Vector<String>, arrayArg, toNativeArray<String>(args[0])); |
3163 imp->overloadedMethod(arrayArg); | 3136 imp->overloadedMethod(arrayArg); |
3164 return v8Undefined(); | 3137 return v8Undefined(); |
3165 } | 3138 } |
3166 | 3139 |
3167 static v8::Handle<v8::Value> overloadedMethod10Method(const v8::Arguments& args) | 3140 static v8::Handle<v8::Value> overloadedMethod10Method(const v8::Arguments& args) |
3168 { | 3141 { |
3169 if (args.Length() < 1) | 3142 if (args.Length() < 1) |
3170 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3143 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3171 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3144 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3172 ExceptionCode ec = 0; | |
3173 V8TRYCATCH(Vector<unsigned>, arrayArg, toNativeArray<unsigned>(args[0])); | 3145 V8TRYCATCH(Vector<unsigned>, arrayArg, toNativeArray<unsigned>(args[0])); |
3174 imp->overloadedMethod(arrayArg); | 3146 imp->overloadedMethod(arrayArg); |
3175 return v8Undefined(); | 3147 return v8Undefined(); |
3176 } | 3148 } |
3177 | 3149 |
3178 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args) | 3150 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args) |
3179 { | 3151 { |
3180 if (args.Length() < 1) | 3152 if (args.Length() < 1) |
3181 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3153 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3182 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3154 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3183 ExceptionCode ec = 0; | |
3184 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3155 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3185 imp->overloadedMethod(strArg); | 3156 imp->overloadedMethod(strArg); |
3186 return v8Undefined(); | 3157 return v8Undefined(); |
3187 } | 3158 } |
3188 | 3159 |
3189 static v8::Handle<v8::Value> overloadedMethodMethod(const v8::Arguments& args) | 3160 static v8::Handle<v8::Value> overloadedMethodMethod(const v8::Arguments& args) |
3190 { | 3161 { |
3191 if ((args.Length() == 2 && (args[0]->IsNull() || V8TestObject::HasInstance(a
rgs[0], args.GetIsolate(), worldType(args.GetIsolate()))) && (args[1]->IsNull()
|| args[1]->IsUndefined() || args[1]->IsString() || args[1]->IsObject()))) | 3162 if ((args.Length() == 2 && (args[0]->IsNull() || V8TestObject::HasInstance(a
rgs[0], args.GetIsolate(), worldType(args.GetIsolate()))) && (args[1]->IsNull()
|| args[1]->IsUndefined() || args[1]->IsString() || args[1]->IsObject()))) |
3192 return overloadedMethod1Method(args); | 3163 return overloadedMethod1Method(args); |
3193 if ((args.Length() == 1 && (args[0]->IsNull() || V8TestObject::HasInstance(a
rgs[0], args.GetIsolate(), worldType(args.GetIsolate())))) || (args.Length() ==
2 && (args[0]->IsNull() || V8TestObject::HasInstance(args[0], args.GetIsolate(),
worldType(args.GetIsolate()))))) | 3164 if ((args.Length() == 1 && (args[0]->IsNull() || V8TestObject::HasInstance(a
rgs[0], args.GetIsolate(), worldType(args.GetIsolate())))) || (args.Length() ==
2 && (args[0]->IsNull() || V8TestObject::HasInstance(args[0], args.GetIsolate(),
worldType(args.GetIsolate()))))) |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3226 return v8Undefined(); | 3197 return v8Undefined(); |
3227 } | 3198 } |
3228 | 3199 |
3229 static v8::Handle<v8::Value> classMethodMethodCallback(const v8::Arguments& args
) | 3200 static v8::Handle<v8::Value> classMethodMethodCallback(const v8::Arguments& args
) |
3230 { | 3201 { |
3231 return TestObjV8Internal::classMethodMethod(args); | 3202 return TestObjV8Internal::classMethodMethod(args); |
3232 } | 3203 } |
3233 | 3204 |
3234 static v8::Handle<v8::Value> classMethodWithOptionalMethod(const v8::Arguments&
args) | 3205 static v8::Handle<v8::Value> classMethodWithOptionalMethod(const v8::Arguments&
args) |
3235 { | 3206 { |
3236 ExceptionCode ec = 0; | |
3237 if (args.Length() <= 0) | 3207 if (args.Length() <= 0) |
3238 return v8Integer(TestObj::classMethodWithOptional(), args.GetIsolate()); | 3208 return v8Integer(TestObj::classMethodWithOptional(), args.GetIsolate()); |
3239 | 3209 |
3240 V8TRYCATCH(int, arg, toInt32(args[0])); | 3210 V8TRYCATCH(int, arg, toInt32(args[0])); |
3241 return v8Integer(TestObj::classMethodWithOptional(arg), args.GetIsolate()); | 3211 return v8Integer(TestObj::classMethodWithOptional(arg), args.GetIsolate()); |
3242 } | 3212 } |
3243 | 3213 |
3244 static v8::Handle<v8::Value> classMethodWithOptionalMethodCallback(const v8::Arg
uments& args) | 3214 static v8::Handle<v8::Value> classMethodWithOptionalMethodCallback(const v8::Arg
uments& args) |
3245 { | 3215 { |
3246 return TestObjV8Internal::classMethodWithOptionalMethod(args); | 3216 return TestObjV8Internal::classMethodWithOptionalMethod(args); |
3247 } | 3217 } |
3248 | 3218 |
3249 static v8::Handle<v8::Value> classMethod2MethodCallback(const v8::Arguments& arg
s) | 3219 static v8::Handle<v8::Value> classMethod2MethodCallback(const v8::Arguments& arg
s) |
3250 { | 3220 { |
3251 return V8TestObject::classMethod2MethodCustom(args); | 3221 return V8TestObject::classMethod2MethodCustom(args); |
3252 } | 3222 } |
3253 | 3223 |
3254 #if ENABLE(Condition1) | 3224 #if ENABLE(Condition1) |
3255 | 3225 |
3256 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args) | 3226 static v8::Handle<v8::Value> overloadedMethod11Method(const v8::Arguments& args) |
3257 { | 3227 { |
3258 if (args.Length() < 1) | 3228 if (args.Length() < 1) |
3259 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3229 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3260 ExceptionCode ec = 0; | |
3261 V8TRYCATCH(int, arg, toInt32(args[0])); | 3230 V8TRYCATCH(int, arg, toInt32(args[0])); |
3262 TestObj::overloadedMethod1(arg); | 3231 TestObj::overloadedMethod1(arg); |
3263 return v8Undefined(); | 3232 return v8Undefined(); |
3264 } | 3233 } |
3265 | 3234 |
3266 #endif // ENABLE(Condition1) | 3235 #endif // ENABLE(Condition1) |
3267 | 3236 |
3268 #if ENABLE(Condition1) | 3237 #if ENABLE(Condition1) |
3269 | 3238 |
3270 static v8::Handle<v8::Value> overloadedMethod12Method(const v8::Arguments& args) | 3239 static v8::Handle<v8::Value> overloadedMethod12Method(const v8::Arguments& args) |
3271 { | 3240 { |
3272 if (args.Length() < 1) | 3241 if (args.Length() < 1) |
3273 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3242 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3274 ExceptionCode ec = 0; | |
3275 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]); | 3243 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, type, args[0]); |
3276 TestObj::overloadedMethod1(type); | 3244 TestObj::overloadedMethod1(type); |
3277 return v8Undefined(); | 3245 return v8Undefined(); |
3278 } | 3246 } |
3279 | 3247 |
3280 #endif // ENABLE(Condition1) | 3248 #endif // ENABLE(Condition1) |
3281 | 3249 |
3282 #if ENABLE(Condition1) | 3250 #if ENABLE(Condition1) |
3283 | 3251 |
3284 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args) | 3252 static v8::Handle<v8::Value> overloadedMethod1Method(const v8::Arguments& args) |
(...skipping 16 matching lines...) Expand all Loading... |
3301 return TestObjV8Internal::overloadedMethod1Method(args); | 3269 return TestObjV8Internal::overloadedMethod1Method(args); |
3302 } | 3270 } |
3303 | 3271 |
3304 #endif // ENABLE(Condition1) | 3272 #endif // ENABLE(Condition1) |
3305 | 3273 |
3306 static v8::Handle<v8::Value> classMethodWithClampMethod(const v8::Arguments& arg
s) | 3274 static v8::Handle<v8::Value> classMethodWithClampMethod(const v8::Arguments& arg
s) |
3307 { | 3275 { |
3308 if (args.Length() < 2) | 3276 if (args.Length() < 2) |
3309 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3277 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3310 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3278 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3311 ExceptionCode ec = 0; | |
3312 unsigned short objArgsShort = 0; | 3279 unsigned short objArgsShort = 0; |
3313 V8TRYCATCH(double, objArgsShortNativeValue, args[0]->NumberValue()); | 3280 V8TRYCATCH(double, objArgsShortNativeValue, args[0]->NumberValue()); |
3314 if (!std::isnan(objArgsShortNativeValue)) | 3281 if (!std::isnan(objArgsShortNativeValue)) |
3315 objArgsShort = clampTo<unsigned short>(objArgsShortNativeValue); | 3282 objArgsShort = clampTo<unsigned short>(objArgsShortNativeValue); |
3316 unsigned long objArgsLong = 0; | 3283 unsigned long objArgsLong = 0; |
3317 V8TRYCATCH(double, objArgsLongNativeValue, args[1]->NumberValue()); | 3284 V8TRYCATCH(double, objArgsLongNativeValue, args[1]->NumberValue()); |
3318 if (!std::isnan(objArgsLongNativeValue)) | 3285 if (!std::isnan(objArgsLongNativeValue)) |
3319 objArgsLong = clampTo<unsigned long>(objArgsLongNativeValue); | 3286 objArgsLong = clampTo<unsigned long>(objArgsLongNativeValue); |
3320 imp->classMethodWithClamp(objArgsShort, objArgsLong); | 3287 imp->classMethodWithClamp(objArgsShort, objArgsLong); |
3321 return v8Undefined(); | 3288 return v8Undefined(); |
3322 } | 3289 } |
3323 | 3290 |
3324 static v8::Handle<v8::Value> classMethodWithClampMethodCallback(const v8::Argume
nts& args) | 3291 static v8::Handle<v8::Value> classMethodWithClampMethodCallback(const v8::Argume
nts& args) |
3325 { | 3292 { |
3326 return TestObjV8Internal::classMethodWithClampMethod(args); | 3293 return TestObjV8Internal::classMethodWithClampMethod(args); |
3327 } | 3294 } |
3328 | 3295 |
3329 static v8::Handle<v8::Value> enabledAtRuntimeMethod1Method(const v8::Arguments&
args) | 3296 static v8::Handle<v8::Value> enabledAtRuntimeMethod1Method(const v8::Arguments&
args) |
3330 { | 3297 { |
3331 if (args.Length() < 1) | 3298 if (args.Length() < 1) |
3332 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3299 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3333 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3300 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3334 ExceptionCode ec = 0; | |
3335 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3301 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3336 imp->enabledAtRuntimeMethod1(longArg); | 3302 imp->enabledAtRuntimeMethod1(longArg); |
3337 return v8Undefined(); | 3303 return v8Undefined(); |
3338 } | 3304 } |
3339 | 3305 |
3340 static v8::Handle<v8::Value> enabledAtRuntimeMethod1MethodCallback(const v8::Arg
uments& args) | 3306 static v8::Handle<v8::Value> enabledAtRuntimeMethod1MethodCallback(const v8::Arg
uments& args) |
3341 { | 3307 { |
3342 return TestObjV8Internal::enabledAtRuntimeMethod1Method(args); | 3308 return TestObjV8Internal::enabledAtRuntimeMethod1Method(args); |
3343 } | 3309 } |
3344 | 3310 |
3345 static v8::Handle<v8::Value> enabledAtRuntimeMethod2Method(const v8::Arguments&
args) | 3311 static v8::Handle<v8::Value> enabledAtRuntimeMethod2Method(const v8::Arguments&
args) |
3346 { | 3312 { |
3347 if (args.Length() < 1) | 3313 if (args.Length() < 1) |
3348 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3314 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3349 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3315 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3350 ExceptionCode ec = 0; | |
3351 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3316 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3352 imp->enabledAtRuntimeMethod2(longArg); | 3317 imp->enabledAtRuntimeMethod2(longArg); |
3353 return v8Undefined(); | 3318 return v8Undefined(); |
3354 } | 3319 } |
3355 | 3320 |
3356 static v8::Handle<v8::Value> enabledAtRuntimeMethod2MethodCallback(const v8::Arg
uments& args) | 3321 static v8::Handle<v8::Value> enabledAtRuntimeMethod2MethodCallback(const v8::Arg
uments& args) |
3357 { | 3322 { |
3358 return TestObjV8Internal::enabledAtRuntimeMethod2Method(args); | 3323 return TestObjV8Internal::enabledAtRuntimeMethod2Method(args); |
3359 } | 3324 } |
3360 | 3325 |
3361 static v8::Handle<v8::Value> enabledPerContextMethod1Method(const v8::Arguments&
args) | 3326 static v8::Handle<v8::Value> enabledPerContextMethod1Method(const v8::Arguments&
args) |
3362 { | 3327 { |
3363 if (args.Length() < 1) | 3328 if (args.Length() < 1) |
3364 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3329 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3365 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3330 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3366 ExceptionCode ec = 0; | |
3367 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3331 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3368 imp->enabledPerContextMethod1(longArg); | 3332 imp->enabledPerContextMethod1(longArg); |
3369 return v8Undefined(); | 3333 return v8Undefined(); |
3370 } | 3334 } |
3371 | 3335 |
3372 static v8::Handle<v8::Value> enabledPerContextMethod1MethodCallback(const v8::Ar
guments& args) | 3336 static v8::Handle<v8::Value> enabledPerContextMethod1MethodCallback(const v8::Ar
guments& args) |
3373 { | 3337 { |
3374 return TestObjV8Internal::enabledPerContextMethod1Method(args); | 3338 return TestObjV8Internal::enabledPerContextMethod1Method(args); |
3375 } | 3339 } |
3376 | 3340 |
3377 static v8::Handle<v8::Value> enabledPerContextMethod2Method(const v8::Arguments&
args) | 3341 static v8::Handle<v8::Value> enabledPerContextMethod2Method(const v8::Arguments&
args) |
3378 { | 3342 { |
3379 if (args.Length() < 1) | 3343 if (args.Length() < 1) |
3380 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3344 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3381 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3345 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3382 ExceptionCode ec = 0; | |
3383 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3346 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3384 imp->enabledPerContextMethod2(longArg); | 3347 imp->enabledPerContextMethod2(longArg); |
3385 return v8Undefined(); | 3348 return v8Undefined(); |
3386 } | 3349 } |
3387 | 3350 |
3388 static v8::Handle<v8::Value> enabledPerContextMethod2MethodCallback(const v8::Ar
guments& args) | 3351 static v8::Handle<v8::Value> enabledPerContextMethod2MethodCallback(const v8::Ar
guments& args) |
3389 { | 3352 { |
3390 return TestObjV8Internal::enabledPerContextMethod2Method(args); | 3353 return TestObjV8Internal::enabledPerContextMethod2Method(args); |
3391 } | 3354 } |
3392 | 3355 |
3393 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethod(const v8::Argu
ments& args) | 3356 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethod(const v8::Argu
ments& args) |
3394 { | 3357 { |
3395 if (args.Length() < 1) | 3358 if (args.Length() < 1) |
3396 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3359 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3397 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3360 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3398 ExceptionCode ec = 0; | |
3399 V8TRYCATCH(Vector<unsigned>, unsignedLongSequence, toNativeArray<unsigned>(a
rgs[0])); | 3361 V8TRYCATCH(Vector<unsigned>, unsignedLongSequence, toNativeArray<unsigned>(a
rgs[0])); |
3400 imp->methodWithUnsignedLongSequence(unsignedLongSequence); | 3362 imp->methodWithUnsignedLongSequence(unsignedLongSequence); |
3401 return v8Undefined(); | 3363 return v8Undefined(); |
3402 } | 3364 } |
3403 | 3365 |
3404 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethodCallback(const
v8::Arguments& args) | 3366 static v8::Handle<v8::Value> methodWithUnsignedLongSequenceMethodCallback(const
v8::Arguments& args) |
3405 { | 3367 { |
3406 return TestObjV8Internal::methodWithUnsignedLongSequenceMethod(args); | 3368 return TestObjV8Internal::methodWithUnsignedLongSequenceMethod(args); |
3407 } | 3369 } |
3408 | 3370 |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3457 static v8::Handle<v8::Value> getSVGDocumentMethodCallback(const v8::Arguments& a
rgs) | 3419 static v8::Handle<v8::Value> getSVGDocumentMethodCallback(const v8::Arguments& a
rgs) |
3458 { | 3420 { |
3459 return TestObjV8Internal::getSVGDocumentMethod(args); | 3421 return TestObjV8Internal::getSVGDocumentMethod(args); |
3460 } | 3422 } |
3461 | 3423 |
3462 static v8::Handle<v8::Value> convert1Method(const v8::Arguments& args) | 3424 static v8::Handle<v8::Value> convert1Method(const v8::Arguments& args) |
3463 { | 3425 { |
3464 if (args.Length() < 1) | 3426 if (args.Length() < 1) |
3465 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3427 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3466 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3428 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3467 ExceptionCode ec = 0; | |
3468 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); | 3429 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); |
3469 imp->convert1(value); | 3430 imp->convert1(value); |
3470 return v8Undefined(); | 3431 return v8Undefined(); |
3471 } | 3432 } |
3472 | 3433 |
3473 static v8::Handle<v8::Value> convert1MethodCallback(const v8::Arguments& args) | 3434 static v8::Handle<v8::Value> convert1MethodCallback(const v8::Arguments& args) |
3474 { | 3435 { |
3475 return TestObjV8Internal::convert1Method(args); | 3436 return TestObjV8Internal::convert1Method(args); |
3476 } | 3437 } |
3477 | 3438 |
3478 static v8::Handle<v8::Value> convert2Method(const v8::Arguments& args) | 3439 static v8::Handle<v8::Value> convert2Method(const v8::Arguments& args) |
3479 { | 3440 { |
3480 if (args.Length() < 1) | 3441 if (args.Length() < 1) |
3481 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3442 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3482 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3443 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3483 ExceptionCode ec = 0; | |
3484 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); | 3444 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); |
3485 imp->convert2(value); | 3445 imp->convert2(value); |
3486 return v8Undefined(); | 3446 return v8Undefined(); |
3487 } | 3447 } |
3488 | 3448 |
3489 static v8::Handle<v8::Value> convert2MethodCallback(const v8::Arguments& args) | 3449 static v8::Handle<v8::Value> convert2MethodCallback(const v8::Arguments& args) |
3490 { | 3450 { |
3491 return TestObjV8Internal::convert2Method(args); | 3451 return TestObjV8Internal::convert2Method(args); |
3492 } | 3452 } |
3493 | 3453 |
3494 static v8::Handle<v8::Value> convert4Method(const v8::Arguments& args) | 3454 static v8::Handle<v8::Value> convert4Method(const v8::Arguments& args) |
3495 { | 3455 { |
3496 if (args.Length() < 1) | 3456 if (args.Length() < 1) |
3497 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3457 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3498 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3458 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3499 ExceptionCode ec = 0; | |
3500 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); | 3459 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); |
3501 imp->convert4(value); | 3460 imp->convert4(value); |
3502 return v8Undefined(); | 3461 return v8Undefined(); |
3503 } | 3462 } |
3504 | 3463 |
3505 static v8::Handle<v8::Value> convert4MethodCallback(const v8::Arguments& args) | 3464 static v8::Handle<v8::Value> convert4MethodCallback(const v8::Arguments& args) |
3506 { | 3465 { |
3507 return TestObjV8Internal::convert4Method(args); | 3466 return TestObjV8Internal::convert4Method(args); |
3508 } | 3467 } |
3509 | 3468 |
3510 static v8::Handle<v8::Value> convert5Method(const v8::Arguments& args) | 3469 static v8::Handle<v8::Value> convert5Method(const v8::Arguments& args) |
3511 { | 3470 { |
3512 if (args.Length() < 1) | 3471 if (args.Length() < 1) |
3513 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3472 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3514 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3473 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3515 ExceptionCode ec = 0; | |
3516 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); | 3474 V8TRYCATCH(TestNode*, value, V8TestNode::HasInstance(args[0], args.GetIsolat
e(), worldType(args.GetIsolate())) ? V8TestNode::toNative(v8::Handle<v8::Object>
::Cast(args[0])) : 0); |
3517 imp->convert5(value); | 3475 imp->convert5(value); |
3518 return v8Undefined(); | 3476 return v8Undefined(); |
3519 } | 3477 } |
3520 | 3478 |
3521 static v8::Handle<v8::Value> convert5MethodCallback(const v8::Arguments& args) | 3479 static v8::Handle<v8::Value> convert5MethodCallback(const v8::Arguments& args) |
3522 { | 3480 { |
3523 return TestObjV8Internal::convert5Method(args); | 3481 return TestObjV8Internal::convert5Method(args); |
3524 } | 3482 } |
3525 | 3483 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3575 static v8::Handle<v8::Value> strictFunctionMethodCallback(const v8::Arguments& a
rgs) | 3533 static v8::Handle<v8::Value> strictFunctionMethodCallback(const v8::Arguments& a
rgs) |
3576 { | 3534 { |
3577 return TestObjV8Internal::strictFunctionMethod(args); | 3535 return TestObjV8Internal::strictFunctionMethod(args); |
3578 } | 3536 } |
3579 | 3537 |
3580 static v8::Handle<v8::Value> variadicStringMethodMethod(const v8::Arguments& arg
s) | 3538 static v8::Handle<v8::Value> variadicStringMethodMethod(const v8::Arguments& arg
s) |
3581 { | 3539 { |
3582 if (args.Length() < 1) | 3540 if (args.Length() < 1) |
3583 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3541 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3584 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3542 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3585 ExceptionCode ec = 0; | |
3586 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, head, args[0]); | 3543 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, head, args[0]); |
3587 V8TRYCATCH(Vector<String>, tail, toNativeArguments<String>(args, 1)); | 3544 V8TRYCATCH(Vector<String>, tail, toNativeArguments<String>(args, 1)); |
3588 imp->variadicStringMethod(head, tail); | 3545 imp->variadicStringMethod(head, tail); |
3589 return v8Undefined(); | 3546 return v8Undefined(); |
3590 } | 3547 } |
3591 | 3548 |
3592 static v8::Handle<v8::Value> variadicStringMethodMethodCallback(const v8::Argume
nts& args) | 3549 static v8::Handle<v8::Value> variadicStringMethodMethodCallback(const v8::Argume
nts& args) |
3593 { | 3550 { |
3594 return TestObjV8Internal::variadicStringMethodMethod(args); | 3551 return TestObjV8Internal::variadicStringMethodMethod(args); |
3595 } | 3552 } |
3596 | 3553 |
3597 static v8::Handle<v8::Value> variadicDoubleMethodMethod(const v8::Arguments& arg
s) | 3554 static v8::Handle<v8::Value> variadicDoubleMethodMethod(const v8::Arguments& arg
s) |
3598 { | 3555 { |
3599 if (args.Length() < 1) | 3556 if (args.Length() < 1) |
3600 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3557 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3601 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3558 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3602 ExceptionCode ec = 0; | |
3603 V8TRYCATCH(double, head, static_cast<double>(args[0]->NumberValue())); | 3559 V8TRYCATCH(double, head, static_cast<double>(args[0]->NumberValue())); |
3604 V8TRYCATCH(Vector<double>, tail, toNativeArguments<double>(args, 1)); | 3560 V8TRYCATCH(Vector<double>, tail, toNativeArguments<double>(args, 1)); |
3605 imp->variadicDoubleMethod(head, tail); | 3561 imp->variadicDoubleMethod(head, tail); |
3606 return v8Undefined(); | 3562 return v8Undefined(); |
3607 } | 3563 } |
3608 | 3564 |
3609 static v8::Handle<v8::Value> variadicDoubleMethodMethodCallback(const v8::Argume
nts& args) | 3565 static v8::Handle<v8::Value> variadicDoubleMethodMethodCallback(const v8::Argume
nts& args) |
3610 { | 3566 { |
3611 return TestObjV8Internal::variadicDoubleMethodMethod(args); | 3567 return TestObjV8Internal::variadicDoubleMethodMethod(args); |
3612 } | 3568 } |
3613 | 3569 |
3614 static v8::Handle<v8::Value> variadicNodeMethodMethod(const v8::Arguments& args) | 3570 static v8::Handle<v8::Value> variadicNodeMethodMethod(const v8::Arguments& args) |
3615 { | 3571 { |
3616 if (args.Length() < 1) | 3572 if (args.Length() < 1) |
3617 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3573 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3618 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3574 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3619 ExceptionCode ec = 0; | |
3620 V8TRYCATCH(Node*, head, V8Node::HasInstance(args[0], args.GetIsolate(), worl
dType(args.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0
])) : 0); | 3575 V8TRYCATCH(Node*, head, V8Node::HasInstance(args[0], args.GetIsolate(), worl
dType(args.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(args[0
])) : 0); |
3621 Vector<RefPtr<Node> > tail; | 3576 Vector<RefPtr<Node> > tail; |
3622 for (int i = 1; i < args.Length(); ++i) { | 3577 for (int i = 1; i < args.Length(); ++i) { |
3623 if (!V8Node::HasInstance(args[i], args.GetIsolate(), worldType(args.GetI
solate()))) | 3578 if (!V8Node::HasInstance(args[i], args.GetIsolate(), worldType(args.GetI
solate()))) |
3624 return throwTypeError(0, args.GetIsolate()); | 3579 return throwTypeError(0, args.GetIsolate()); |
3625 tail.append(V8Node::toNative(v8::Handle<v8::Object>::Cast(args[i]))); | 3580 tail.append(V8Node::toNative(v8::Handle<v8::Object>::Cast(args[i]))); |
3626 } | 3581 } |
3627 imp->variadicNodeMethod(head, tail); | 3582 imp->variadicNodeMethod(head, tail); |
3628 return v8Undefined(); | 3583 return v8Undefined(); |
3629 } | 3584 } |
(...skipping 25 matching lines...) Expand all Loading... |
3655 static v8::Handle<v8::Value> perWorldMethodMethodCallbackForMainWorld(const v8::
Arguments& args) | 3610 static v8::Handle<v8::Value> perWorldMethodMethodCallbackForMainWorld(const v8::
Arguments& args) |
3656 { | 3611 { |
3657 return TestObjV8Internal::perWorldMethodMethodForMainWorld(args); | 3612 return TestObjV8Internal::perWorldMethodMethodForMainWorld(args); |
3658 } | 3613 } |
3659 | 3614 |
3660 static v8::Handle<v8::Value> overloadedPerWorldMethod1Method(const v8::Arguments
& args) | 3615 static v8::Handle<v8::Value> overloadedPerWorldMethod1Method(const v8::Arguments
& args) |
3661 { | 3616 { |
3662 if (args.Length() < 1) | 3617 if (args.Length() < 1) |
3663 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3618 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3664 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3619 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3665 ExceptionCode ec = 0; | |
3666 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3620 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3667 imp->overloadedPerWorldMethod(longArg); | 3621 imp->overloadedPerWorldMethod(longArg); |
3668 return v8Undefined(); | 3622 return v8Undefined(); |
3669 } | 3623 } |
3670 | 3624 |
3671 static v8::Handle<v8::Value> overloadedPerWorldMethod1MethodForMainWorld(const v
8::Arguments& args) | 3625 static v8::Handle<v8::Value> overloadedPerWorldMethod1MethodForMainWorld(const v
8::Arguments& args) |
3672 { | 3626 { |
3673 if (args.Length() < 1) | 3627 if (args.Length() < 1) |
3674 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3628 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3675 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3629 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3676 ExceptionCode ec = 0; | |
3677 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3630 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3678 imp->overloadedPerWorldMethod(longArg); | 3631 imp->overloadedPerWorldMethod(longArg); |
3679 return v8Undefined(); | 3632 return v8Undefined(); |
3680 } | 3633 } |
3681 | 3634 |
3682 static v8::Handle<v8::Value> overloadedPerWorldMethod2Method(const v8::Arguments
& args) | 3635 static v8::Handle<v8::Value> overloadedPerWorldMethod2Method(const v8::Arguments
& args) |
3683 { | 3636 { |
3684 if (args.Length() < 2) | 3637 if (args.Length() < 2) |
3685 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3638 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3686 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3639 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3687 ExceptionCode ec = 0; | |
3688 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3640 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3689 V8TRYCATCH(int, longArg, toInt32(args[1])); | 3641 V8TRYCATCH(int, longArg, toInt32(args[1])); |
3690 imp->overloadedPerWorldMethod(strArg, longArg); | 3642 imp->overloadedPerWorldMethod(strArg, longArg); |
3691 return v8Undefined(); | 3643 return v8Undefined(); |
3692 } | 3644 } |
3693 | 3645 |
3694 static v8::Handle<v8::Value> overloadedPerWorldMethod2MethodForMainWorld(const v
8::Arguments& args) | 3646 static v8::Handle<v8::Value> overloadedPerWorldMethod2MethodForMainWorld(const v
8::Arguments& args) |
3695 { | 3647 { |
3696 if (args.Length() < 2) | 3648 if (args.Length() < 2) |
3697 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3649 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3698 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3650 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3699 ExceptionCode ec = 0; | |
3700 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3651 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3701 V8TRYCATCH(int, longArg, toInt32(args[1])); | 3652 V8TRYCATCH(int, longArg, toInt32(args[1])); |
3702 imp->overloadedPerWorldMethod(strArg, longArg); | 3653 imp->overloadedPerWorldMethod(strArg, longArg); |
3703 return v8Undefined(); | 3654 return v8Undefined(); |
3704 } | 3655 } |
3705 | 3656 |
3706 static v8::Handle<v8::Value> overloadedPerWorldMethodMethod(const v8::Arguments&
args) | 3657 static v8::Handle<v8::Value> overloadedPerWorldMethodMethod(const v8::Arguments&
args) |
3707 { | 3658 { |
3708 if (args.Length() == 1) | 3659 if (args.Length() == 1) |
3709 return overloadedPerWorldMethod1Method(args); | 3660 return overloadedPerWorldMethod1Method(args); |
(...skipping 23 matching lines...) Expand all Loading... |
3733 static v8::Handle<v8::Value> overloadedPerWorldMethodMethodCallbackForMainWorld(
const v8::Arguments& args) | 3684 static v8::Handle<v8::Value> overloadedPerWorldMethodMethodCallbackForMainWorld(
const v8::Arguments& args) |
3734 { | 3685 { |
3735 return TestObjV8Internal::overloadedPerWorldMethodMethodForMainWorld(args); | 3686 return TestObjV8Internal::overloadedPerWorldMethodMethodForMainWorld(args); |
3736 } | 3687 } |
3737 | 3688 |
3738 static v8::Handle<v8::Value> activityLoggedMethod1Method(const v8::Arguments& ar
gs) | 3689 static v8::Handle<v8::Value> activityLoggedMethod1Method(const v8::Arguments& ar
gs) |
3739 { | 3690 { |
3740 if (args.Length() < 1) | 3691 if (args.Length() < 1) |
3741 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3692 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3742 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3693 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3743 ExceptionCode ec = 0; | |
3744 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3694 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3745 imp->activityLoggedMethod1(longArg); | 3695 imp->activityLoggedMethod1(longArg); |
3746 return v8Undefined(); | 3696 return v8Undefined(); |
3747 } | 3697 } |
3748 | 3698 |
3749 static v8::Handle<v8::Value> activityLoggedMethod1MethodCallback(const v8::Argum
ents& args) | 3699 static v8::Handle<v8::Value> activityLoggedMethod1MethodCallback(const v8::Argum
ents& args) |
3750 { | 3700 { |
3751 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); | 3701 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); |
3752 if (contextData && contextData->activityLogger()) { | 3702 if (contextData && contextData->activityLogger()) { |
3753 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); | 3703 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); |
3754 contextData->activityLogger()->log("TestObject.activityLoggedMethod1", a
rgs.Length(), loggerArgs.data(), "Method"); | 3704 contextData->activityLogger()->log("TestObject.activityLoggedMethod1", a
rgs.Length(), loggerArgs.data(), "Method"); |
3755 } | 3705 } |
3756 return TestObjV8Internal::activityLoggedMethod1Method(args); | 3706 return TestObjV8Internal::activityLoggedMethod1Method(args); |
3757 } | 3707 } |
3758 | 3708 |
3759 static v8::Handle<v8::Value> activityLoggedMethod2Method(const v8::Arguments& ar
gs) | 3709 static v8::Handle<v8::Value> activityLoggedMethod2Method(const v8::Arguments& ar
gs) |
3760 { | 3710 { |
3761 if (args.Length() < 1) | 3711 if (args.Length() < 1) |
3762 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3712 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3763 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3713 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3764 ExceptionCode ec = 0; | |
3765 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3714 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3766 imp->activityLoggedMethod2(longArg); | 3715 imp->activityLoggedMethod2(longArg); |
3767 return v8Undefined(); | 3716 return v8Undefined(); |
3768 } | 3717 } |
3769 | 3718 |
3770 static v8::Handle<v8::Value> activityLoggedMethod2MethodForMainWorld(const v8::A
rguments& args) | 3719 static v8::Handle<v8::Value> activityLoggedMethod2MethodForMainWorld(const v8::A
rguments& args) |
3771 { | 3720 { |
3772 if (args.Length() < 1) | 3721 if (args.Length() < 1) |
3773 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3722 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3774 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3723 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3775 ExceptionCode ec = 0; | |
3776 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3724 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3777 imp->activityLoggedMethod2(longArg); | 3725 imp->activityLoggedMethod2(longArg); |
3778 return v8Undefined(); | 3726 return v8Undefined(); |
3779 } | 3727 } |
3780 | 3728 |
3781 static v8::Handle<v8::Value> activityLoggedMethod2MethodCallback(const v8::Argum
ents& args) | 3729 static v8::Handle<v8::Value> activityLoggedMethod2MethodCallback(const v8::Argum
ents& args) |
3782 { | 3730 { |
3783 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); | 3731 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); |
3784 if (contextData && contextData->activityLogger()) { | 3732 if (contextData && contextData->activityLogger()) { |
3785 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); | 3733 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); |
(...skipping 10 matching lines...) Expand all Loading... |
3796 contextData->activityLogger()->log("TestObject.activityLoggedMethod2", a
rgs.Length(), loggerArgs.data(), "Method"); | 3744 contextData->activityLogger()->log("TestObject.activityLoggedMethod2", a
rgs.Length(), loggerArgs.data(), "Method"); |
3797 } | 3745 } |
3798 return TestObjV8Internal::activityLoggedMethod2MethodForMainWorld(args); | 3746 return TestObjV8Internal::activityLoggedMethod2MethodForMainWorld(args); |
3799 } | 3747 } |
3800 | 3748 |
3801 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethod(const v8:
:Arguments& args) | 3749 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethod(const v8:
:Arguments& args) |
3802 { | 3750 { |
3803 if (args.Length() < 1) | 3751 if (args.Length() < 1) |
3804 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3752 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3805 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3753 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3806 ExceptionCode ec = 0; | |
3807 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3754 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3808 imp->activityLoggedInIsolatedWorldMethod(longArg); | 3755 imp->activityLoggedInIsolatedWorldMethod(longArg); |
3809 return v8Undefined(); | 3756 return v8Undefined(); |
3810 } | 3757 } |
3811 | 3758 |
3812 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodForMainWor
ld(const v8::Arguments& args) | 3759 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodForMainWor
ld(const v8::Arguments& args) |
3813 { | 3760 { |
3814 if (args.Length() < 1) | 3761 if (args.Length() < 1) |
3815 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3762 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3816 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3763 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3817 ExceptionCode ec = 0; | |
3818 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3764 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3819 imp->activityLoggedInIsolatedWorldMethod(longArg); | 3765 imp->activityLoggedInIsolatedWorldMethod(longArg); |
3820 return v8Undefined(); | 3766 return v8Undefined(); |
3821 } | 3767 } |
3822 | 3768 |
3823 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallback(c
onst v8::Arguments& args) | 3769 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallback(c
onst v8::Arguments& args) |
3824 { | 3770 { |
3825 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); | 3771 V8PerContextData* contextData = V8PerContextData::from(args.GetIsolate()->Ge
tCurrentContext()); |
3826 if (contextData && contextData->activityLogger()) { | 3772 if (contextData && contextData->activityLogger()) { |
3827 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); | 3773 Vector<v8::Handle<v8::Value> > loggerArgs = toVectorOfArguments(args); |
3828 contextData->activityLogger()->log("TestObject.activityLoggedInIsolatedW
orldMethod", args.Length(), loggerArgs.data(), "Method"); | 3774 contextData->activityLogger()->log("TestObject.activityLoggedInIsolatedW
orldMethod", args.Length(), loggerArgs.data(), "Method"); |
3829 } | 3775 } |
3830 return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethod(args); | 3776 return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethod(args); |
3831 } | 3777 } |
3832 | 3778 |
3833 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallbackFo
rMainWorld(const v8::Arguments& args) | 3779 static v8::Handle<v8::Value> activityLoggedInIsolatedWorldMethodMethodCallbackFo
rMainWorld(const v8::Arguments& args) |
3834 { | 3780 { |
3835 return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethodForMainWo
rld(args); | 3781 return TestObjV8Internal::activityLoggedInIsolatedWorldMethodMethodForMainWo
rld(args); |
3836 } | 3782 } |
3837 | 3783 |
3838 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1Method(const v8::Arg
uments& args) | 3784 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1Method(const v8::Arg
uments& args) |
3839 { | 3785 { |
3840 if (args.Length() < 1) | 3786 if (args.Length() < 1) |
3841 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3787 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3842 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3788 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3843 ExceptionCode ec = 0; | |
3844 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3789 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3845 imp->overloadedActivityLoggedMethod(longArg); | 3790 imp->overloadedActivityLoggedMethod(longArg); |
3846 return v8Undefined(); | 3791 return v8Undefined(); |
3847 } | 3792 } |
3848 | 3793 |
3849 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1MethodForMainWorld(c
onst v8::Arguments& args) | 3794 static v8::Handle<v8::Value> overloadedActivityLoggedMethod1MethodForMainWorld(c
onst v8::Arguments& args) |
3850 { | 3795 { |
3851 if (args.Length() < 1) | 3796 if (args.Length() < 1) |
3852 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3797 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3853 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3798 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3854 ExceptionCode ec = 0; | |
3855 V8TRYCATCH(int, longArg, toInt32(args[0])); | 3799 V8TRYCATCH(int, longArg, toInt32(args[0])); |
3856 imp->overloadedActivityLoggedMethod(longArg); | 3800 imp->overloadedActivityLoggedMethod(longArg); |
3857 return v8Undefined(); | 3801 return v8Undefined(); |
3858 } | 3802 } |
3859 | 3803 |
3860 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2Method(const v8::Arg
uments& args) | 3804 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2Method(const v8::Arg
uments& args) |
3861 { | 3805 { |
3862 if (args.Length() < 2) | 3806 if (args.Length() < 2) |
3863 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3807 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3864 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3808 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3865 ExceptionCode ec = 0; | |
3866 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3809 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3867 V8TRYCATCH(int, longArg, toInt32(args[1])); | 3810 V8TRYCATCH(int, longArg, toInt32(args[1])); |
3868 imp->overloadedActivityLoggedMethod(strArg, longArg); | 3811 imp->overloadedActivityLoggedMethod(strArg, longArg); |
3869 return v8Undefined(); | 3812 return v8Undefined(); |
3870 } | 3813 } |
3871 | 3814 |
3872 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2MethodForMainWorld(c
onst v8::Arguments& args) | 3815 static v8::Handle<v8::Value> overloadedActivityLoggedMethod2MethodForMainWorld(c
onst v8::Arguments& args) |
3873 { | 3816 { |
3874 if (args.Length() < 2) | 3817 if (args.Length() < 2) |
3875 return throwNotEnoughArgumentsError(args.GetIsolate()); | 3818 return throwNotEnoughArgumentsError(args.GetIsolate()); |
3876 TestObj* imp = V8TestObject::toNative(args.Holder()); | 3819 TestObj* imp = V8TestObject::toNative(args.Holder()); |
3877 ExceptionCode ec = 0; | |
3878 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); | 3820 V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, strArg, args[0]); |
3879 V8TRYCATCH(int, longArg, toInt32(args[1])); | 3821 V8TRYCATCH(int, longArg, toInt32(args[1])); |
3880 imp->overloadedActivityLoggedMethod(strArg, longArg); | 3822 imp->overloadedActivityLoggedMethod(strArg, longArg); |
3881 return v8Undefined(); | 3823 return v8Undefined(); |
3882 } | 3824 } |
3883 | 3825 |
3884 static v8::Handle<v8::Value> overloadedActivityLoggedMethodMethod(const v8::Argu
ments& args) | 3826 static v8::Handle<v8::Value> overloadedActivityLoggedMethodMethod(const v8::Argu
ments& args) |
3885 { | 3827 { |
3886 if (args.Length() == 1) | 3828 if (args.Length() == 1) |
3887 return overloadedActivityLoggedMethod1Method(args); | 3829 return overloadedActivityLoggedMethod1Method(args); |
(...skipping 576 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4464 installPerContextProperties(wrapper, impl.get(), isolate); | 4406 installPerContextProperties(wrapper, impl.get(), isolate); |
4465 V8DOMWrapper::associateObjectWithWrapper(impl, &info, wrapper, isolate, Wrap
perConfiguration::Independent); | 4407 V8DOMWrapper::associateObjectWithWrapper(impl, &info, wrapper, isolate, Wrap
perConfiguration::Independent); |
4466 return wrapper; | 4408 return wrapper; |
4467 } | 4409 } |
4468 void V8TestObject::derefObject(void* object) | 4410 void V8TestObject::derefObject(void* object) |
4469 { | 4411 { |
4470 static_cast<TestObj*>(object)->deref(); | 4412 static_cast<TestObj*>(object)->deref(); |
4471 } | 4413 } |
4472 | 4414 |
4473 } // namespace WebCore | 4415 } // namespace WebCore |
OLD | NEW |