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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 724733002: Support for [Clamp] and [EnforceRange] to IDL dictionary. (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Created 6 years, 1 month 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/templates/dictionary_v8.cpp ('K') | « Source/bindings/templates/dictionary_v8.cpp ('k') | Source/core/testing/DictionaryTest.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/bindings/tests/results/core/V8TestDictionary.cpp
diff --git a/Source/bindings/tests/results/core/V8TestDictionary.cpp b/Source/bindings/tests/results/core/V8TestDictionary.cpp
index 324c3351ccbd2ff1b2f577deb677a2dfb983a6a6..61724812dde812286531440e3125443a0c20c09f 100644
--- a/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -32,40 +32,45 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
// FIXME: Remove this v8::TryCatch once the code is switched from
// Dictionary/DictionaryHelper to something that uses ExceptionState.
v8::TryCatch block;
- bool booleanMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "booleanMember", booleanMember)) {
+ v8::Local<v8::Value> booleanMemberValue;
+ if (dictionary.getKey("booleanMember", booleanMemberValue) && !isUndefinedOrNull(booleanMemberValue)) {
+ bool booleanMember = booleanMemberValue->BooleanValue();
impl.setBooleanMember(booleanMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- bool create;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "create", create)) {
+ v8::Local<v8::Value> createValue;
+ if (dictionary.getKey("create", createValue) && !isUndefinedOrNull(createValue)) {
+ bool create = createValue->BooleanValue();
impl.setCreateMember(create);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- double doubleOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "doubleOrNullMember", doubleOrNullMember)) {
+ v8::Local<v8::Value> doubleOrNullMemberValue;
+ if (dictionary.getKey("doubleOrNullMember", doubleOrNullMemberValue) && !isUndefinedOrNull(doubleOrNullMemberValue)) {
+ TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
impl.setDoubleOrNullMember(doubleOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RefPtrWillBeRawPtr<Element> elementOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "elementOrNullMember", elementOrNullMember)) {
+ v8::Local<v8::Value> elementOrNullMemberValue;
+ if (dictionary.getKey("elementOrNullMember", elementOrNullMemberValue) && !isUndefinedOrNull(elementOrNullMemberValue)) {
+ Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
impl.setElementOrNullMember(elementOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- String enumMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "enumMember", enumMember)) {
+ v8::Local<v8::Value> enumMemberValue;
+ if (dictionary.getKey("enumMember", enumMemberValue) && !isUndefinedOrNull(enumMemberValue)) {
+ TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
String string = enumMember;
if (!(string == "foo" || string == "bar" || string == "baz")) {
exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
@@ -77,16 +82,18 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
return;
}
- int longMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "longMember", longMember)) {
+ v8::Local<v8::Value> longMemberValue;
+ if (dictionary.getKey("longMember", longMemberValue) && !isUndefinedOrNull(longMemberValue)) {
+ TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
impl.setLongMember(longMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- ScriptValue objectMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "objectMember", objectMember)) {
+ v8::Local<v8::Value> objectMemberValue;
+ if (dictionary.getKey("objectMember", objectMemberValue) && !isUndefinedOrNull(objectMemberValue)) {
+ ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
if (!objectMember.isObject()) {
exceptionState.throwTypeError("member objectMember is not an object.");
return;
@@ -97,8 +104,9 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
return;
}
- ScriptValue objectOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "objectOrNullMember", objectOrNullMember)) {
+ v8::Local<v8::Value> objectOrNullMemberValue;
+ if (dictionary.getKey("objectOrNullMember", objectOrNullMemberValue) && !isUndefinedOrNull(objectOrNullMemberValue)) {
+ ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
if (!objectOrNullMember.isObject()) {
exceptionState.throwTypeError("member objectOrNullMember is not an object.");
return;
@@ -109,80 +117,90 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Handle<v8::Value> v8Valu
return;
}
- Vector<String> stringArrayMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "stringArrayMember", stringArrayMember)) {
+ v8::Local<v8::Value> stringArrayMemberValue;
+ if (dictionary.getKey("stringArrayMember", stringArrayMemberValue) && !isUndefinedOrNull(stringArrayMemberValue)) {
+ TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
impl.setStringArrayMember(stringArrayMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- String stringMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "stringMember", stringMember)) {
+ v8::Local<v8::Value> stringMemberValue;
+ if (dictionary.getKey("stringMember", stringMemberValue) && !isUndefinedOrNull(stringMemberValue)) {
+ TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
impl.setStringMember(stringMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- String stringOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "stringOrNullMember", stringOrNullMember)) {
+ v8::Local<v8::Value> stringOrNullMemberValue;
+ if (dictionary.getKey("stringOrNullMember", stringOrNullMemberValue) && !isUndefinedOrNull(stringOrNullMemberValue)) {
+ TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
impl.setStringOrNullMember(stringOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- Vector<String> stringSequenceMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "stringSequenceMember", stringSequenceMember)) {
+ v8::Local<v8::Value> stringSequenceMemberValue;
+ if (dictionary.getKey("stringSequenceMember", stringSequenceMemberValue) && !isUndefinedOrNull(stringSequenceMemberValue)) {
+ TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
impl.setStringSequenceMember(stringSequenceMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceGarbageCollectedMember", testInterfaceGarbageCollectedMember)) {
+ v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue;
+ if (dictionary.getKey("testInterfaceGarbageCollectedMember", testInterfaceGarbageCollectedMemberValue) && !isUndefinedOrNull(testInterfaceGarbageCollectedMemberValue)) {
+ TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceGarbageCollectedOrNullMember", testInterfaceGarbageCollectedOrNullMember)) {
+ v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue;
+ if (dictionary.getKey("testInterfaceGarbageCollectedOrNullMember", testInterfaceGarbageCollectedOrNullMemberValue) && !isUndefinedOrNull(testInterfaceGarbageCollectedOrNullMemberValue)) {
+ TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RefPtr<TestInterfaceImplementation> testInterfaceMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceMember", testInterfaceMember)) {
+ v8::Local<v8::Value> testInterfaceMemberValue;
+ if (dictionary.getKey("testInterfaceMember", testInterfaceMemberValue) && !isUndefinedOrNull(testInterfaceMemberValue)) {
+ TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
impl.setTestInterfaceMember(testInterfaceMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RefPtr<TestInterfaceImplementation> testInterfaceOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceOrNullMember", testInterfaceOrNullMember)) {
+ v8::Local<v8::Value> testInterfaceOrNullMemberValue;
+ if (dictionary.getKey("testInterfaceOrNullMember", testInterfaceOrNullMemberValue) && !isUndefinedOrNull(testInterfaceOrNullMemberValue)) {
+ TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceWillBeGarbageCollectedMember", testInterfaceWillBeGarbageCollectedMember)) {
+ v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue;
+ if (dictionary.getKey("testInterfaceWillBeGarbageCollectedMember", testInterfaceWillBeGarbageCollectedMemberValue) && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedMemberValue)) {
+ TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
return;
}
- RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedOrNullMember;
- if (DictionaryHelper::getWithUndefinedOrNullCheck(dictionary, "testInterfaceWillBeGarbageCollectedOrNullMember", testInterfaceWillBeGarbageCollectedOrNullMember)) {
+ v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue;
+ if (dictionary.getKey("testInterfaceWillBeGarbageCollectedOrNullMember", testInterfaceWillBeGarbageCollectedOrNullMemberValue) && !isUndefinedOrNull(testInterfaceWillBeGarbageCollectedOrNullMemberValue)) {
+ TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
} else if (block.HasCaught()) {
exceptionState.rethrowV8Exception(block.Exception());
« Source/bindings/templates/dictionary_v8.cpp ('K') | « Source/bindings/templates/dictionary_v8.cpp ('k') | Source/core/testing/DictionaryTest.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698