Improve handling of dictionary conversions.

Source/bindings/v8/Dictionary.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 73 matching lines @@
     return !isUndefinedOrNull() && m_options->IsObject();
 }
 
 bool Dictionary::isUndefinedOrNull() const
 {
     if (m_options.IsEmpty())
         return true;
     return WebCore::isUndefinedOrNull(m_options);
 }
 
+bool Dictionary::hasProperty(const String& key) const
+{
+    if (isUndefinedOrNull())
+        return false;
+    v8::Local<v8::Object> options = m_options->ToObject();
+    ASSERT(!options.IsEmpty());
+
+    ASSERT(m_isolate);
+    ASSERT(m_isolate == v8::Isolate::GetCurrent());
+    v8::Handle<v8::String> v8Key = v8String(key, m_isolate);
+    if (!options->Has(v8Key))
+        return false;
+
+    return true;
+}
+
 bool Dictionary::getKey(const String& key, v8::Local<v8::Value>& value) const
 {
     if (isUndefinedOrNull())
         return false;
     v8::Local<v8::Object> options = m_options->ToObject();
     ASSERT(!options.IsEmpty());
 
     ASSERT(m_isolate);
     ASSERT(m_isolate == v8::Isolate::GetCurrent());
     v8::Handle<v8::String> v8Key = v8String(key, m_isolate);
@@ skipping 16 matching lines @@
     if (!getKey(key, v8Value))
         return false;
 
     v8::Local<v8::Boolean> v8Bool = v8Value->ToBoolean();
     if (v8Bool.IsEmpty())
         return false;
     value = v8Bool->Value();
     return true;
 }
 
+bool Dictionary::convert(const String& key, bool& value, ExceptionState&) const
+{
+    get(key, value);
+    return true;
+}
+
 bool Dictionary::get(const String& key, int32_t& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32();
     if (v8Int32.IsEmpty())
         return false;
     value = v8Int32->Value();
     return true;
 }
 
 bool Dictionary::get(const String& key, double& value, bool& hasValue) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value)) {
         hasValue = false;
         return false;
     }
 
     hasValue = true;
-    v8::Local<v8::Number> v8Number = v8Value->ToNumber();
+    V8TRYCATCH_RETURN(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
     if (v8Number.IsEmpty())
         return false;
     value = v8Number->Value();
     return true;
 }
 
 bool Dictionary::get(const String& key, double& value) const
 {
     bool unused;
     return get(key, value, unused);
 }
 
+bool Dictionary::convert(const String& key, double& value, ExceptionState& exceptionState) const
+{
+    bool hasValue = false;
+    if (!get(key, value, hasValue) && hasValue) {
+        exceptionState.throwTypeError(ExceptionMessages::illTypedProperty(key, "is not of type 'double'."));

[Mike West, 2013/11/25 08:22:48]

So, as I noted in an earlier comment, I'd like to see something like
`ExceptionMessages::failedToConstruct('xxx',
ExceptionMessages::illTypedProperty(key, ...));`

It's not clear to me when these conversion methods are called, however. If it's
difficult to distinguish between construction and other types of conversion,
then that nicety might not be worth it.

[sof, 2013/11/25 11:57:23]

I like the suggestion, we should do it. I'm reasonably certain that these
conversions are currently only called upon for event constructors, but that
might well change.

I could extend the method signatures to pass in the context of use, and emit
error messages based on that, but this makes the case for a single constant
context parameter recording this & other settings, even more compelling. Will
give that a go.

[sof, 2013/11/25 23:24:05]

Done.

+        return false;
+    }
+    return true;
+}
+
 bool Dictionary::get(const String& key, String& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
     value = stringValue;
     return true;
 }
 
+bool Dictionary::convert(const String& key, String& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
+    value = stringValue;
+    return true;
+}
+
 bool Dictionary::get(const String& key, ScriptValue& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     value = ScriptValue(v8Value, m_isolate);
     return true;
 }
 
+bool Dictionary::convert(const String& key, ScriptValue& value, ExceptionState&) const
+{
+    get(key, value);
+    return true;
+}
+
 bool Dictionary::get(const String& key, unsigned short& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32();
     if (v8Int32.IsEmpty())
         return false;
     value = static_cast<unsigned short>(v8Int32->Value());
@@ skipping 38 matching lines @@
     value = static_cast<unsigned long>(v8Integer->Value());
     return true;
 }
 
 bool Dictionary::get(const String& key, unsigned long long& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
-    v8::Local<v8::Number> v8Number = v8Value->ToNumber();
+    V8TRYCATCH_RETURN(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
     if (v8Number.IsEmpty())
         return false;
     double d = v8Number->Value();
     doubleToInteger(d, value);
     return true;
 }
 
 bool Dictionary::get(const String& key, RefPtr<DOMWindow>& value) const
 {
     v8::Local<v8::Value> v8Value;
@@ skipping 28 matching lines @@
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     ASSERT(m_isolate);
     ASSERT(m_isolate == v8::Isolate::GetCurrent());
     return getMessagePortArray(v8Value, key, value, m_isolate);
 }
 
+bool Dictionary::convert(const String& key, const String&, bool isNullable, MessagePortArray& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    return get(key, value);
+}
+
 bool Dictionary::get(const String& key, HashSet<AtomicString>& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     // FIXME: Support array-like objects
     if (!v8Value->IsArray())
         return false;
 
     ASSERT(m_isolate);
     ASSERT(m_isolate == v8::Isolate::GetCurrent());
     v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
     for (size_t i = 0; i < v8Array->Length(); ++i) {
         v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(i, m_isolate));
         V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, false);
         value.add(stringValue);
     }
 
     return true;
 }
 
+bool Dictionary::convert(const String& key, const String&, bool isNullable, HashSet<AtomicString>& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    if (isNullable && WebCore::isUndefinedOrNull(v8Value))
+        return true;
+
+    if (!v8Value->IsArray()) {
+        exceptionState.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
+        return false;
+    }
+
+    return get(key, value);
+}
+
 bool Dictionary::getWithUndefinedOrNullCheck(const String& key, String& value) const
 {
     v8::Local<v8::Value> v8Value;
-    if (!getKey(key, v8Value) || v8Value->IsNull() || v8Value->IsUndefined())
+    if (!getKey(key, v8Value) || WebCore::isUndefinedOrNull(v8Value))
         return false;
 
-    if (WebCore::isUndefinedOrNull(v8Value)) {
-        value = String();
-        return true;
-    }
-
     V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, v8Value, false);
     value = stringValue;
     return true;
 }
 
 bool Dictionary::get(const String& key, RefPtr<Uint8Array>& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
@@ skipping 141 matching lines @@
 
     if (v8Value->IsObject()) {
         ASSERT(m_isolate);
         ASSERT(m_isolate == v8::Isolate::GetCurrent());
         value = Dictionary(v8Value, m_isolate);
     }
 
     return true;
 }
 
+bool Dictionary::convert(const String& key, const String&, bool isNullable, Dictionary& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    if (v8Value->IsObject())
+        return get(key, value);
+
+    if (isNullable && WebCore::isUndefinedOrNull(v8Value))
+        return true;
+
+    exceptionState.throwTypeError(ExceptionMessages::illTypedProperty(key, "does not have a Dictionary type."));
+    return false;
+}
+
 bool Dictionary::get(const String& key, Vector<String>& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     if (!v8Value->IsArray())
         return false;
 
     v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
     for (size_t i = 0; i < v8Array->Length(); ++i) {
         v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Uint32::New(i, m_isolate));
         V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringValue, indexedValue, false);
         value.append(stringValue);
     }
 
     return true;
 }
 
+bool Dictionary::convert(const String& key, const String&, bool isNullable, Vector<String>& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    if (isNullable && WebCore::isUndefinedOrNull(v8Value))
+        return true;
+
+    if (!v8Value->IsArray()) {
+        exceptionState.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
+        return false;
+    }
+
+    return get(key, value);
+}
+
 bool Dictionary::get(const String& key, ArrayValue& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     if (!v8Value->IsArray())
         return false;
 
     ASSERT(m_isolate);
     ASSERT(m_isolate == v8::Isolate::GetCurrent());
     value = ArrayValue(v8::Local<v8::Array>::Cast(v8Value), m_isolate);
     return true;
 }
 
+bool Dictionary::convert(const String& key, const String&, bool isNullable, ArrayValue& value, ExceptionState& exceptionState) const
+{
+    v8::Local<v8::Value> v8Value;
+    if (!getKey(key, v8Value))
+        return true;
+
+    if (isNullable && WebCore::isUndefinedOrNull(v8Value))
+        return true;
+
+    if (!v8Value->IsArray()) {
+        exceptionState.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
+        return false;
+    }
+
+    return get(key, value);
+}
+
 bool Dictionary::get(const String& key, RefPtr<DOMError>& value) const
 {
     v8::Local<v8::Value> v8Value;
     if (!getKey(key, v8Value))
         return false;
 
     DOMError* error = 0;
     if (v8Value->IsObject()) {
         v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value);
         v8::Handle<v8::Object> domError = wrapper->FindInstanceInPrototypeChain(V8DOMError::GetTemplate(m_isolate, worldType(m_isolate)));
@@ skipping 61 matching lines @@
         if (!options->Has(key))
             continue;
         V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<>, stringKey, key, false);
         names.append(stringKey);
     }
 
     return true;
 }
 
 } // namespace WebCore