Source/bindings/tests/results/core/V8TestObject.cpp - Issue 611953003: Canvas2D Performance: fix the bottleneck of hasInstance during JS binding -- overloading

Unified Diff: Source/bindings/tests/results/core/V8TestObject.cpp

Issue 611953003: Canvas2D Performance: fix the bottleneck of hasInstance during JS binding -- overloading (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: add code change in Source/bindings/tests/results/ Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« Source/bindings/scripts/v8_interface.py ('K') | « Source/bindings/tests/results/core/V8TestInterfaceWillBeGarbageCollected.cpp ('k') | Source/bindings/tests/results/core/V8TestSpecialOperations.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: Source/bindings/tests/results/core/V8TestObject.cpp

diff --git a/Source/bindings/tests/results/core/V8TestObject.cpp b/Source/bindings/tests/results/core/V8TestObject.cpp

index 87298836b17007369a4930d579c747320847e931..ce61f1d7c72d281ac5eb2d0e6a528fa62b2e71f3 100644

--- a/Source/bindings/tests/results/core/V8TestObject.cpp

+++ b/Source/bindings/tests/results/core/V8TestObject.cpp

@@ -729,7 +729,7 @@ static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Va

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue));

}

@@ -758,7 +758,7 @@ static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestObject* cppValue = V8TestObject::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestObject* cppValue = V8TestObject::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestObjectAttribute(WTF::getPtr(cppValue));

}

@@ -1111,7 +1111,7 @@ static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- Document* cppValue = V8Document::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ Document* cppValue = V8Document::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setDocumentAttribute(WTF::getPtr(cppValue));

}

@@ -1140,7 +1140,7 @@ static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Valu

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- DocumentFragment* cppValue = V8DocumentFragment::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ DocumentFragment* cppValue = V8DocumentFragment::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue));

}

@@ -1169,7 +1169,7 @@ static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, c

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- DocumentType* cppValue = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ DocumentType* cppValue = V8DocumentType::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setDocumentTypeAttribute(WTF::getPtr(cppValue));

}

@@ -1198,7 +1198,7 @@ static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- Element* cppValue = V8Element::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ Element* cppValue = V8Element::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setElementAttribute(WTF::getPtr(cppValue));

}

@@ -1227,7 +1227,7 @@ static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setNodeAttribute(WTF::getPtr(cppValue));

}

@@ -1256,7 +1256,7 @@ static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, con

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- ShadowRoot* cppValue = V8ShadowRoot::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ ShadowRoot* cppValue = V8ShadowRoot::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setShadowRootAttribute(WTF::getPtr(cppValue));

}

@@ -1611,7 +1611,7 @@ static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8V

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue));

}

@@ -3062,7 +3062,7 @@ static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value

RawPtr<TestInterfaceGarbageCollected> impl = WTF::getPtr(proxyImpl->locationGarbageCollected());

if (!impl)

return;

- TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setAttr1(WTF::getPtr(cppValue));

}

@@ -3101,7 +3101,7 @@ static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v

RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(proxyImpl->locationWillBeGarbageCollected());

if (!impl)

return;

- TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setAttr1(WTF::getPtr(cppValue));

}

@@ -3235,7 +3235,7 @@ static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<

v8::Handle<v8::Object> holder = info.Holder();

ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptionTestInterfaceEmptyAttribute", "TestObject", holder, info.GetIsolate());

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), exceptionState);

exceptionState.throwIfNeeded();

}

@@ -3310,7 +3310,7 @@ static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;

impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr(cppValue));

}

@@ -3341,7 +3341,7 @@ static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;

impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppValue));

}

@@ -4463,7 +4463,7 @@ static void typeCheckingInterfaceTestInterfaceAttributeAttributeSetter(v8::Local

return;

}

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTypeCheckingInterfaceTestInterfaceAttribute(WTF::getPtr(cppValue));

}

@@ -4498,7 +4498,7 @@ static void typeCheckingInterfaceTestInterfaceOrNullAttributeAttributeSetter(v8:

return;

}

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTypeCheckingInterfaceTestInterfaceOrNullAttribute(WTF::getPtr(cppValue));

}

@@ -4619,7 +4619,7 @@ static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value,

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceAttribute(WTF::getPtr(cppValue));

}

@@ -4648,7 +4648,7 @@ static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceGarbageCollectedAttribute(WTF::getPtr(cppValue));

}

@@ -4677,7 +4677,7 @@ static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Loca

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue));

}

@@ -4706,7 +4706,7 @@ static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Loca

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue));

}

@@ -4735,7 +4735,7 @@ static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ TestInterfaceWillBeGarbageCollected* cppValue = V8TestInterfaceWillBeGarbageCollected::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue));

}

@@ -4849,7 +4849,7 @@ static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8:

{

v8::Handle<v8::Object> holder = info.Holder();

TestObject* impl = V8TestObject::toImpl(holder);

- Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value);

+ Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

V8TestObject::PrivateScript::nodeAttributeAttributeSetter(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()), impl, cppValue);

}

@@ -5578,7 +5578,7 @@ static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyArg;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);

}

@@ -5603,7 +5603,7 @@ static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallb

TestInterfaceEmpty* testInterfaceEmptyArg;

{

TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[1]));

}

impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg);

}

@@ -5747,7 +5747,7 @@ static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i

TestObject* impl = V8TestObject::toImpl(info.Holder());

Attr* attrArg;

{

- attrArg = V8Attr::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ attrArg = V8Attr::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodAttrArg(attrArg);

}

@@ -5768,7 +5768,7 @@ static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value

TestObject* impl = V8TestObject::toImpl(info.Holder());

Document* documentArg;

{

- documentArg = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ documentArg = V8Document::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodDocumentArg(documentArg);

}

@@ -5789,7 +5789,7 @@ static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::V

TestObject* impl = V8TestObject::toImpl(info.Holder());

DocumentType* documentTypeArg;

{

- documentTypeArg = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ documentTypeArg = V8DocumentType::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodDocumentTypeArg(documentTypeArg);

}

@@ -5810,7 +5810,7 @@ static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>

TestObject* impl = V8TestObject::toImpl(info.Holder());

Element* elementArg;

{

- elementArg = V8Element::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ elementArg = V8Element::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodElementArg(elementArg);

}

@@ -5831,7 +5831,7 @@ static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& i

TestObject* impl = V8TestObject::toImpl(info.Holder());

Node* nodeArg;

{

- nodeArg = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ nodeArg = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodNodeArg(nodeArg);

}

@@ -6419,7 +6419,7 @@ static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallba

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* nullableTestInterfaceEmptyArg;

{

- nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg);

}

@@ -6905,7 +6905,7 @@ static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCall

impl->voidMethodOptionalTestInterfaceEmptyArg();

return;

}

- optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg);

}

@@ -7086,7 +7086,7 @@ static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::Funct

impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);

return;

}

- optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]);

+ optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[1]));

}

impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInterfaceEmpty);

}

@@ -7110,7 +7110,7 @@ static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::Funct

TestInterfaceEmpty* optionalTestInterfaceEmpty;

int longArg;

{

- optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

if (UNLIKELY(info.Length() <= 1)) {

impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty);

return;

@@ -7338,7 +7338,7 @@ static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCa

TestInterfaceImplementation* defaultTestInterfaceArg;

{

if (!info[0]->IsUndefined()) {

- defaultTestInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ defaultTestInterfaceArg = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

} else {

defaultTestInterfaceArg = nullptr;

}

@@ -7433,7 +7433,7 @@ static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(c

TestInterfaceEmpty* testInterfaceEmptyArg;

Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

for (int i = 1; i < info.Length(); ++i) {

if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {

exceptionState.throwTypeError("parameter 2 is not of type 'TestInterfaceEmpty'.");

@@ -7643,7 +7643,7 @@ static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>&

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyArg;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->overloadedMethodC(testInterfaceEmptyArg);

}

@@ -7746,7 +7746,7 @@ static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>&

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyOrNullArg;

{

- testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->overloadedMethodE(testInterfaceEmptyOrNullArg);

}

@@ -7871,7 +7871,7 @@ static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>&

TestInterfaceEmpty* testInterfaceEmptyOrNullArg;

{

if (!info[0]->IsUndefined()) {

- testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

} else {

testInterfaceEmptyOrNullArg = nullptr;

}

@@ -7928,7 +7928,7 @@ static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>&

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceImplementation* testInterfaceArg;

{

- testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceArg = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->overloadedMethodH(testInterfaceArg);

}

@@ -7938,7 +7938,7 @@ static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>&

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyArg;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->overloadedMethodH(testInterfaceEmptyArg);

}

@@ -8291,7 +8291,7 @@ static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::Func

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg;

{

- defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestInterfaceEmptyArg);

}

@@ -9121,7 +9121,7 @@ static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::Func

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyArg;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);

}

@@ -9142,7 +9142,7 @@ static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(co

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceEmpty* testInterfaceEmptyArg;

{

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);

}

@@ -9513,7 +9513,7 @@ static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::Functio

TestObject* impl = V8TestObject::toImpl(info.Holder());

TestInterfaceImplementation* testInterface;

{

- testInterface = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterface = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface);

}

@@ -9662,7 +9662,7 @@ static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(const v8:

V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());

return;

}

- testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);

}

@@ -9927,7 +9927,7 @@ static void nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(const v8:

TestObject* impl = V8TestObject::toImpl(info.Holder());

Node* value;

{

- value = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);

+ value = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

}

RefPtrWillBeRawPtr<Node> result = nullptr;

if (!V8TestObject::PrivateScript::nodeMethodWithNodeArgumentImplementedInPrivateScriptMethod(toFrameIfNotDetached(info.GetIsolate()->GetCurrentContext()), impl, value, &result))

@@ -9957,8 +9957,8 @@ static void nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethod(const

double value2;

V8StringResource<> string;

{

- document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);

- node = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);

+ document = V8Document::toImpl(v8::Handle<v8::Object>::Cast(info[0]));

+ node = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[1]));

TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value1, toInt16(info[2], exceptionState), exceptionState);

TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(value2, toDouble(info[3], exceptionState), exceptionState);

TOSTRING_VOID_INTERNAL(string, info[4]);

@@ -10721,7 +10721,7 @@ bool V8TestObject::PrivateScript::nodeMethodWithNodeArgumentImplementedInPrivate

v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptState, scriptStateInUserScript, "TestObject", "nodeMethodWithNodeArgumentImplementedInPrivateScript", holder, 1, argv);

if (v8Value.IsEmpty())

return false;

- Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value);

+ Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

*result = cppValue;

RELEASE_ASSERT(!exceptionState.hadException());

return true;

@@ -10754,7 +10754,7 @@ bool V8TestObject::PrivateScript::nodeMethodWithVariousArgumentsImplementedInPri

v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMMethod(scriptState, scriptStateInUserScript, "TestObject", "nodeMethodWithVariousArgumentsImplementedInPrivateScript", holder, 5, argv);

if (v8Value.IsEmpty())

return false;

- Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value);

+ Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

*result = cppValue;

RELEASE_ASSERT(!exceptionState.hadException());

return true;

@@ -10934,7 +10934,7 @@ bool V8TestObject::PrivateScript::nodeAttributeAttributeGetter(LocalFrame* frame

v8::Handle<v8::Value> v8Value = PrivateScriptRunner::runDOMAttributeGetter(scriptState, scriptStateInUserScript, "TestObject", "nodeAttribute", holder);

if (v8Value.IsEmpty())

return false;

- Node* cppValue = V8Node::toImplWithTypeCheck(scriptState->isolate(), v8Value);

+ Node* cppValue = V8Node::toImpl(v8::Handle<v8::Object>::Cast(v8Value));

RELEASE_ASSERT(!exceptionState.hadException());

*result = cppValue;

return true;