Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(164)

Issues Search
    My Issues | Starred     Open | Closed | All

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: update auto-generated code for test cases I added, the change in JS binding is applied Created 6 years, 2 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_methods.py ('K') | « Source/bindings/tests/idls/core/TestObject.idl ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments 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 1dc608d512367616408aee0d7039fcf7e5617acf..78527670e8b1a5de438a3b44d4feeecc45a7eb0d 100644
--- a/Source/bindings/tests/results/core/V8TestObject.cpp
+++ b/Source/bindings/tests/results/core/V8TestObject.cpp
@@ -9999,6 +9999,414 @@ static void methodImplementedInCPPForPrivateScriptOnlyMethodCallback(const v8::F
TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
}
+static void typeCheckingMaybeRedundantForOverloadingMethodsA1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ int b;
+ {
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsA(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsA2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ int a;
+ int b;
+ {
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsA(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsAMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 2:
+ if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsA1Method(info);
+ return;
+ }
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsA2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsAMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsAMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsB1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ {
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsB(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsB2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ int a;
+ int b;
+ {
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsB(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsBMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 1:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsB1Method(info);
+ return;
+ }
+ break;
+ case 2:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsB2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsBMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsBMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsC1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ {
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsC2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsC", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ int a;
+ int b;
+ {
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsCMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsC", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 1:
+ if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsC1Method(info);
+ return;
+ }
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsC2Method(info);
+ return;
+ }
+ break;
+ case 2:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsC2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsCMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsCMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsD1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ Node* b;
+ {
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsD(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsD2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ int b;
+ {
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ exceptionState.throwTypeError("parameter 1 is not of type 'Node'.");
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsD(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsDMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 2:
+ if (V8Node::hasInstance(info[1], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsD1Method(info);
+ return;
+ }
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsD2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsDMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsDMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsE1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ Node* b;
+ {
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsE2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", info.Holder(), info.GetIsolate());
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ int b;
+ {
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ exceptionState.throwTypeError("parameter 1 is not of type 'Node'.");
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a);
+ return;
+ }
+ TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsEMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 1:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info);
+ return;
+ }
+ break;
+ case 2:
+ if (info[1]->IsUndefined()) {
+ typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info);
+ return;
+ }
+ if (V8Node::hasInstance(info[1], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsE1Method(info);
+ return;
+ }
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsEMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsEMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsF1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Node* a;
+ {
+ if (UNLIKELY(info.Length() <= 0)) {
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsF();
+ return;
+ }
+ if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+ return;
+ }
+ a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsF2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TestObject* impl = V8TestObject::toImpl(info.Holder());
+ Document* a;
+ Node* b;
+ {
+ if (info.Length() > 0 && !V8Document::hasInstance(info[0], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 1 is not of type 'Document'."), info.GetIsolate());
+ return;
+ }
+ a = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+ if (UNLIKELY(info.Length() <= 1)) {
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a);
+ return;
+ }
+ if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
+ V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
+ return;
+ }
+ b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+ }
+ impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsFMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", info.Holder(), info.GetIsolate());
+ switch (std::min(2, info.Length())) {
+ case 0:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info);
+ return;
+ }
+ break;
+ case 1:
+ if (info[0]->IsUndefined()) {
+ typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info);
+ return;
+ }
+ if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info);
+ return;
+ }
+ if (V8Document::hasInstance(info[0], info.GetIsolate())) {
+ typeCheckingMaybeRedundantForOverloadingMethodsF2Method(info);
+ return;
+ }
+ break;
+ case 2:
+ if (true) {
+ typeCheckingMaybeRedundantForOverloadingMethodsF2Method(info);
+ return;
+ }
+ break;
+ default:
+ exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
+ exceptionState.throwIfNeeded();
+ return;
+ }
+ exceptionState.throwTypeError("No function was found that matched the signature provided.");
+ exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsFMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+ TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+ TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsFMethod(info);
+ TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
static void toStringMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TestObject* impl = V8TestObject::toImpl(info.Holder());
@@ -10384,6 +10792,12 @@ static const V8DOMConfiguration::MethodConfiguration V8TestObjectMethods[] = {
{"nodeMethodWithNodeArgumentImplementedInPrivateScript", TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
{"nodeMethodWithVariousArgumentsImplementedInPrivateScript", TestObjectV8Internal::nodeMethodWithVariousArgumentsImplementedInPrivateScriptMethodCallback, 0, 5, V8DOMConfiguration::ExposedToAllScripts},
{"methodImplementedInCPPForPrivateScriptOnly", TestObjectV8Internal::methodImplementedInCPPForPrivateScriptOnlyMethodCallback, 0, 2, V8DOMConfiguration::OnlyExposedToPrivateScript},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsA", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsAMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsB", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsBMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsC", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsCMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsD", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsDMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsE", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsEMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+ {"typeCheckingMaybeRedundantForOverloadingMethodsF", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsFMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
{"toString", TestObjectV8Internal::toStringMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
};
« Source/bindings/scripts/v8_methods.py ('K') | « Source/bindings/tests/idls/core/TestObject.idl ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698