IDL: Support default values for dictionary members of union types

Source/bindings/tests/results/core/UnionTypesCore.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "config.h"
 #include "bindings/core/v8/UnionTypesCore.h"
 
 #include "bindings/core/v8/Dictionary.h"
@@ skipping 31 matching lines @@
     return m_arrayBuffer;
 }
 
 void ArrayBufferOrArrayBufferViewOrDictionary::setArrayBuffer(PassRefPtr<TestArrayBuffer> value)
 {
     ASSERT(isNull());
     m_arrayBuffer = value;
     m_type = SpecificTypeArrayBuffer;
 }
 
+ArrayBufferOrArrayBufferViewOrDictionary ArrayBufferOrArrayBufferViewOrDictionary::fromArrayBuffer(PassRefPtr<TestArrayBuffer> value)
+{
+    ArrayBufferOrArrayBufferViewOrDictionary container;
+    container.setArrayBuffer(value);
+    return container;
+}
+
 PassRefPtr<TestArrayBufferView> ArrayBufferOrArrayBufferViewOrDictionary::getAsArrayBufferView() const
 {
     ASSERT(isArrayBufferView());
     return m_arrayBufferView;
 }
 
 void ArrayBufferOrArrayBufferViewOrDictionary::setArrayBufferView(PassRefPtr<TestArrayBufferView> value)
 {
     ASSERT(isNull());
     m_arrayBufferView = value;
     m_type = SpecificTypeArrayBufferView;
 }
 
+ArrayBufferOrArrayBufferViewOrDictionary ArrayBufferOrArrayBufferViewOrDictionary::fromArrayBufferView(PassRefPtr<TestArrayBufferView> value)
+{
+    ArrayBufferOrArrayBufferViewOrDictionary container;
+    container.setArrayBufferView(value);
+    return container;
+}
+
 Dictionary ArrayBufferOrArrayBufferViewOrDictionary::getAsDictionary() const
 {
     ASSERT(isDictionary());
     return m_dictionary;
 }
 
 void ArrayBufferOrArrayBufferViewOrDictionary::setDictionary(Dictionary value)
 {
     ASSERT(isNull());
     m_dictionary = value;
     m_type = SpecificTypeDictionary;
 }
 
+ArrayBufferOrArrayBufferViewOrDictionary ArrayBufferOrArrayBufferViewOrDictionary::fromDictionary(Dictionary value)
+{
+    ArrayBufferOrArrayBufferViewOrDictionary container;
+    container.setDictionary(value);
+    return container;
+}
+
 void V8ArrayBufferOrArrayBufferViewOrDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, ArrayBufferOrArrayBufferViewOrDictionary& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (V8ArrayBuffer::hasInstance(v8Value, isolate)) {
         RefPtr<TestArrayBuffer> cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBuffer(cppValue);
         return;
     }
@@ skipping 48 matching lines @@
     return m_boolean;
 }
 
 void BooleanOrStringOrUnrestrictedDouble::setBoolean(bool value)
 {
     ASSERT(isNull());
     m_boolean = value;
     m_type = SpecificTypeBoolean;
 }
 
+BooleanOrStringOrUnrestrictedDouble BooleanOrStringOrUnrestrictedDouble::fromBoolean(bool value)
+{
+    BooleanOrStringOrUnrestrictedDouble container;
+    container.setBoolean(value);
+    return container;
+}
+
 String BooleanOrStringOrUnrestrictedDouble::getAsString() const
 {
     ASSERT(isString());
     return m_string;
 }
 
 void BooleanOrStringOrUnrestrictedDouble::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+BooleanOrStringOrUnrestrictedDouble BooleanOrStringOrUnrestrictedDouble::fromString(String value)
+{
+    BooleanOrStringOrUnrestrictedDouble container;
+    container.setString(value);
+    return container;
+}
+
 double BooleanOrStringOrUnrestrictedDouble::getAsUnrestrictedDouble() const
 {
     ASSERT(isUnrestrictedDouble());
     return m_unrestrictedDouble;
 }
 
 void BooleanOrStringOrUnrestrictedDouble::setUnrestrictedDouble(double value)
 {
     ASSERT(isNull());
     m_unrestrictedDouble = value;
     m_type = SpecificTypeUnrestrictedDouble;
 }
 
+BooleanOrStringOrUnrestrictedDouble BooleanOrStringOrUnrestrictedDouble::fromUnrestrictedDouble(double value)
+{
+    BooleanOrStringOrUnrestrictedDouble container;
+    container.setUnrestrictedDouble(value);
+    return container;
+}
+
 void V8BooleanOrStringOrUnrestrictedDouble::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, BooleanOrStringOrUnrestrictedDouble& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsBoolean()) {
         impl.setBoolean(v8Value->ToBoolean()->Value());
         return;
     }
 
@@ skipping 46 matching lines @@
     return m_double;
 }
 
 void DoubleOrString::setDouble(double value)
 {
     ASSERT(isNull());
     m_double = value;
     m_type = SpecificTypeDouble;
 }
 
+DoubleOrString DoubleOrString::fromDouble(double value)
+{
+    DoubleOrString container;
+    container.setDouble(value);
+    return container;
+}
+
 String DoubleOrString::getAsString() const
 {
     ASSERT(isString());
     return m_string;
 }
 
 void DoubleOrString::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+DoubleOrString DoubleOrString::fromString(String value)
+{
+    DoubleOrString container;
+    container.setString(value);
+    return container;
+}
+
 void V8DoubleOrString::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, DoubleOrString& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsNumber()) {
         TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toRestrictedDouble(v8Value, exceptionState), exceptionState);
         impl.setDouble(cppValue);
         return;
     }
@@ skipping 39 matching lines @@
     return m_node;
 }
 
 void NodeOrNodeList::setNode(PassRefPtrWillBeRawPtr<Node> value)
 {
     ASSERT(isNull());
     m_node = value;
     m_type = SpecificTypeNode;
 }
 
+NodeOrNodeList NodeOrNodeList::fromNode(PassRefPtrWillBeRawPtr<Node> value)
+{
+    NodeOrNodeList container;
+    container.setNode(value);
+    return container;
+}
+
 PassRefPtrWillBeRawPtr<NodeList> NodeOrNodeList::getAsNodeList() const
 {
     ASSERT(isNodeList());
     return m_nodeList;
 }
 
 void NodeOrNodeList::setNodeList(PassRefPtrWillBeRawPtr<NodeList> value)
 {
     ASSERT(isNull());
     m_nodeList = value;
     m_type = SpecificTypeNodeList;
 }
 
+NodeOrNodeList NodeOrNodeList::fromNodeList(PassRefPtrWillBeRawPtr<NodeList> value)
+{
+    NodeOrNodeList container;
+    container.setNodeList(value);
+    return container;
+}
+
 void NodeOrNodeList::trace(Visitor* visitor)
 {
     visitor->trace(m_node);
     visitor->trace(m_nodeList);
 }
 
 void V8NodeOrNodeList::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, NodeOrNodeList& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
@@ skipping 46 matching lines @@
     return m_string;
 }
 
 void StringOrArrayBufferOrArrayBufferView::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+StringOrArrayBufferOrArrayBufferView StringOrArrayBufferOrArrayBufferView::fromString(String value)
+{
+    StringOrArrayBufferOrArrayBufferView container;
+    container.setString(value);
+    return container;
+}
+
 PassRefPtr<TestArrayBuffer> StringOrArrayBufferOrArrayBufferView::getAsArrayBuffer() const
 {
     ASSERT(isArrayBuffer());
     return m_arrayBuffer;
 }
 
 void StringOrArrayBufferOrArrayBufferView::setArrayBuffer(PassRefPtr<TestArrayBuffer> value)
 {
     ASSERT(isNull());
     m_arrayBuffer = value;
     m_type = SpecificTypeArrayBuffer;
 }
 
+StringOrArrayBufferOrArrayBufferView StringOrArrayBufferOrArrayBufferView::fromArrayBuffer(PassRefPtr<TestArrayBuffer> value)
+{
+    StringOrArrayBufferOrArrayBufferView container;
+    container.setArrayBuffer(value);
+    return container;
+}
+
 PassRefPtr<TestArrayBufferView> StringOrArrayBufferOrArrayBufferView::getAsArrayBufferView() const
 {
     ASSERT(isArrayBufferView());
     return m_arrayBufferView;
 }
 
 void StringOrArrayBufferOrArrayBufferView::setArrayBufferView(PassRefPtr<TestArrayBufferView> value)
 {
     ASSERT(isNull());
     m_arrayBufferView = value;
     m_type = SpecificTypeArrayBufferView;
 }
 
+StringOrArrayBufferOrArrayBufferView StringOrArrayBufferOrArrayBufferView::fromArrayBufferView(PassRefPtr<TestArrayBufferView> value)
+{
+    StringOrArrayBufferOrArrayBufferView container;
+    container.setArrayBufferView(value);
+    return container;
+}
+
 void V8StringOrArrayBufferOrArrayBufferView::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, StringOrArrayBufferOrArrayBufferView& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (V8ArrayBuffer::hasInstance(v8Value, isolate)) {
         RefPtr<TestArrayBuffer> cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBuffer(cppValue);
         return;
     }
@@ skipping 47 matching lines @@
     return m_string;
 }
 
 void StringOrDouble::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+StringOrDouble StringOrDouble::fromString(String value)
+{
+    StringOrDouble container;
+    container.setString(value);
+    return container;
+}
+
 double StringOrDouble::getAsDouble() const
 {
     ASSERT(isDouble());
     return m_double;
 }
 
 void StringOrDouble::setDouble(double value)
 {
     ASSERT(isNull());
     m_double = value;
     m_type = SpecificTypeDouble;
 }
 
+StringOrDouble StringOrDouble::fromDouble(double value)
+{
+    StringOrDouble container;
+    container.setDouble(value);
+    return container;
+}
+
 void V8StringOrDouble::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, StringOrDouble& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsNumber()) {
         TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toRestrictedDouble(v8Value, exceptionState), exceptionState);
         impl.setDouble(cppValue);
         return;
     }
@@ skipping 39 matching lines @@
     return m_string;
 }
 
 void StringOrStringSequence::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+StringOrStringSequence StringOrStringSequence::fromString(String value)
+{
+    StringOrStringSequence container;
+    container.setString(value);
+    return container;
+}
+
 const Vector<String>& StringOrStringSequence::getAsStringSequence() const
 {
     ASSERT(isStringSequence());
     return m_stringSequence;
 }
 
 void StringOrStringSequence::setStringSequence(const Vector<String>& value)
 {
     ASSERT(isNull());
     m_stringSequence = value;
     m_type = SpecificTypeStringSequence;
 }
 
+StringOrStringSequence StringOrStringSequence::fromStringSequence(const Vector<String>& value)
+{
+    StringOrStringSequence container;
+    container.setStringSequence(value);
+    return container;
+}
+
 void V8StringOrStringSequence::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, StringOrStringSequence& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsArray()) {
         TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, cppValue, toImplArray<String>(v8Value, 0, isolate, exceptionState), exceptionState);
         impl.setStringSequence(cppValue);
         return;
     }
@@ skipping 44 matching lines @@
     ASSERT(isNull());
     String string = value;
     if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
         ASSERT_NOT_REACHED();
         return;
     }
     m_testEnum = value;
     m_type = SpecificTypeTestEnum;
 }
 
+TestEnumOrDouble TestEnumOrDouble::fromTestEnum(String value)
+{
+    TestEnumOrDouble container;
+    container.setTestEnum(value);
+    return container;
+}
+
 double TestEnumOrDouble::getAsDouble() const
 {
     ASSERT(isDouble());
     return m_double;
 }
 
 void TestEnumOrDouble::setDouble(double value)
 {
     ASSERT(isNull());
     m_double = value;
     m_type = SpecificTypeDouble;
 }
 
+TestEnumOrDouble TestEnumOrDouble::fromDouble(double value)
+{
+    TestEnumOrDouble container;
+    container.setDouble(value);
+    return container;
+}
+
 void V8TestEnumOrDouble::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestEnumOrDouble& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsNumber()) {
         TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toRestrictedDouble(v8Value, exceptionState), exceptionState);
         impl.setDouble(cppValue);
         return;
     }
@@ skipping 44 matching lines @@
     return m_testInterface2;
 }
 
 void TestInterface2OrUint8Array::setTestInterface2(PassRefPtr<TestInterface2> value)
 {
     ASSERT(isNull());
     m_testInterface2 = value;
     m_type = SpecificTypeTestInterface2;
 }
 
+TestInterface2OrUint8Array TestInterface2OrUint8Array::fromTestInterface2(PassRefPtr<TestInterface2> value)
+{
+    TestInterface2OrUint8Array container;
+    container.setTestInterface2(value);
+    return container;
+}
+
 PassRefPtr<DOMUint8Array> TestInterface2OrUint8Array::getAsUint8Array() const
 {
     ASSERT(isUint8Array());
     return m_uint8Array;
 }
 
 void TestInterface2OrUint8Array::setUint8Array(PassRefPtr<DOMUint8Array> value)
 {
     ASSERT(isNull());
     m_uint8Array = value;
     m_type = SpecificTypeUint8Array;
 }
 
+TestInterface2OrUint8Array TestInterface2OrUint8Array::fromUint8Array(PassRefPtr<DOMUint8Array> value)
+{
+    TestInterface2OrUint8Array container;
+    container.setUint8Array(value);
+    return container;
+}
+
 void V8TestInterface2OrUint8Array::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterface2OrUint8Array& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (V8TestInterface2::hasInstance(v8Value, isolate)) {
         RefPtr<TestInterface2> cppValue = V8TestInterface2::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface2(cppValue);
         return;
     }
@@ skipping 40 matching lines @@
     return m_testInterfaceGarbageCollected;
 }
 
 void TestInterfaceGarbageCollectedOrString::setTestInterfaceGarbageCollected(TestInterfaceGarbageCollected* value)
 {
     ASSERT(isNull());
     m_testInterfaceGarbageCollected = value;
     m_type = SpecificTypeTestInterfaceGarbageCollected;
 }
 
+TestInterfaceGarbageCollectedOrString TestInterfaceGarbageCollectedOrString::fromTestInterfaceGarbageCollected(TestInterfaceGarbageCollected* value)
+{
+    TestInterfaceGarbageCollectedOrString container;
+    container.setTestInterfaceGarbageCollected(value);
+    return container;
+}
+
 String TestInterfaceGarbageCollectedOrString::getAsString() const
 {
     ASSERT(isString());
     return m_string;
 }
 
 void TestInterfaceGarbageCollectedOrString::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+TestInterfaceGarbageCollectedOrString TestInterfaceGarbageCollectedOrString::fromString(String value)
+{
+    TestInterfaceGarbageCollectedOrString container;
+    container.setString(value);
+    return container;
+}
+
 void TestInterfaceGarbageCollectedOrString::trace(Visitor* visitor)
 {
     visitor->trace(m_testInterfaceGarbageCollected);
 }
 
 void V8TestInterfaceGarbageCollectedOrString::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceGarbageCollectedOrString& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
@@ skipping 44 matching lines @@
     return m_testInterface;
 }
 
 void TestInterfaceOrLong::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
 {
     ASSERT(isNull());
     m_testInterface = value;
     m_type = SpecificTypeTestInterface;
 }
 
+TestInterfaceOrLong TestInterfaceOrLong::fromTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+{
+    TestInterfaceOrLong container;
+    container.setTestInterface(value);
+    return container;
+}
+
 int TestInterfaceOrLong::getAsLong() const
 {
     ASSERT(isLong());
     return m_long;
 }
 
 void TestInterfaceOrLong::setLong(int value)
 {
     ASSERT(isNull());
     m_long = value;
     m_type = SpecificTypeLong;
 }
 
+TestInterfaceOrLong TestInterfaceOrLong::fromLong(int value)
+{
+    TestInterfaceOrLong container;
+    container.setLong(value);
+    return container;
+}
+
 void V8TestInterfaceOrLong::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceOrLong& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (V8TestInterface::hasInstance(v8Value, isolate)) {
         RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface(cppValue);
         return;
     }
@@ skipping 45 matching lines @@
     return m_testInterface;
 }
 
 void TestInterfaceOrTestInterfaceEmpty::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
 {
     ASSERT(isNull());
     m_testInterface = value;
     m_type = SpecificTypeTestInterface;
 }
 
+TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+{
+    TestInterfaceOrTestInterfaceEmpty container;
+    container.setTestInterface(value);
+    return container;
+}
+
 PassRefPtr<TestInterfaceEmpty> TestInterfaceOrTestInterfaceEmpty::getAsTestInterfaceEmpty() const
 {
     ASSERT(isTestInterfaceEmpty());
     return m_testInterfaceEmpty;
 }
 
 void TestInterfaceOrTestInterfaceEmpty::setTestInterfaceEmpty(PassRefPtr<TestInterfaceEmpty> value)
 {
     ASSERT(isNull());
     m_testInterfaceEmpty = value;
     m_type = SpecificTypeTestInterfaceEmpty;
 }
 
+TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterfaceEmpty(PassRefPtr<TestInterfaceEmpty> value)
+{
+    TestInterfaceOrTestInterfaceEmpty container;
+    container.setTestInterfaceEmpty(value);
+    return container;
+}
+
 void V8TestInterfaceOrTestInterfaceEmpty::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceOrTestInterfaceEmpty& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (V8TestInterface::hasInstance(v8Value, isolate)) {
         RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface(cppValue);
         return;
     }
@@ skipping 40 matching lines @@
     return m_testInterfaceWillBeGarbageCollected;
 }
 
 void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value)
 {
     ASSERT(isNull());
     m_testInterfaceWillBeGarbageCollected = value;
     m_type = SpecificTypeTestInterfaceWillBeGarbageCollected;
 }
 
+TestInterfaceWillBeGarbageCollectedOrTestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::fromTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value)
+{
+    TestInterfaceWillBeGarbageCollectedOrTestDictionary container;
+    container.setTestInterfaceWillBeGarbageCollected(value);
+    return container;
+}
+
 TestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::getAsTestDictionary() const
 {
     ASSERT(isTestDictionary());
     return m_testDictionary;
 }
 
 void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestDictionary(TestDictionary value)
 {
     ASSERT(isNull());
     m_testDictionary = value;
     m_type = SpecificTypeTestDictionary;
 }
 
+TestInterfaceWillBeGarbageCollectedOrTestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::fromTestDictionary(TestDictionary value)
+{
+    TestInterfaceWillBeGarbageCollectedOrTestDictionary container;
+    container.setTestDictionary(value);
+    return container;
+}
+
 void TestInterfaceWillBeGarbageCollectedOrTestDictionary::trace(Visitor* visitor)
 {
     visitor->trace(m_testInterfaceWillBeGarbageCollected);
     visitor->trace(m_testDictionary);
 }
 
 void V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
@@ skipping 47 matching lines @@
     return m_unrestrictedDouble;
 }
 
 void UnrestrictedDoubleOrString::setUnrestrictedDouble(double value)
 {
     ASSERT(isNull());
     m_unrestrictedDouble = value;
     m_type = SpecificTypeUnrestrictedDouble;
 }
 
+UnrestrictedDoubleOrString UnrestrictedDoubleOrString::fromUnrestrictedDouble(double value)
+{
+    UnrestrictedDoubleOrString container;
+    container.setUnrestrictedDouble(value);
+    return container;
+}
+
 String UnrestrictedDoubleOrString::getAsString() const
 {
     ASSERT(isString());
     return m_string;
 }
 
 void UnrestrictedDoubleOrString::setString(String value)
 {
     ASSERT(isNull());
     m_string = value;
     m_type = SpecificTypeString;
 }
 
+UnrestrictedDoubleOrString UnrestrictedDoubleOrString::fromString(String value)
+{
+    UnrestrictedDoubleOrString container;
+    container.setString(value);
+    return container;
+}
+
 void V8UnrestrictedDoubleOrString::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, UnrestrictedDoubleOrString& impl, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (v8Value->IsNumber()) {
         TONATIVE_VOID_EXCEPTIONSTATE(double, cppValue, toDouble(v8Value, exceptionState), exceptionState);
         impl.setUnrestrictedDouble(cppValue);
         return;
     }
@@ skipping 22 matching lines @@
 }
 
 UnrestrictedDoubleOrString NativeValueTraits<UnrestrictedDoubleOrString>::nativeValue(const v8::Local<v8::Value>& value, v8::Isolate* isolate, ExceptionState& exceptionState)
 {
     UnrestrictedDoubleOrString impl;
     V8UnrestrictedDoubleOrString::toImpl(isolate, value, impl, exceptionState);
     return impl;
 }
 
 } // namespace blink