Support missing and invalid defaults for reflected attributes.

Source/bindings/scripts/code_generator_v8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 1490 matching lines @@
     } else {
         my $reflect = $attribute->extendedAttributes->{"Reflect"};
         my $url = $attribute->extendedAttributes->{"URL"};
         if ($reflect && !$url && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute getter:
             my ($functionName, @arguments) = GetterExpression($interfaceName, $attribute);
             my $getterExpression = "imp->${functionName}(" . join(", ", @arguments) . ")";
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             if ($attribute->extendedAttributes->{"ReflectOnly"}) {
                 $code .= "    String resultValue = ${getterExpression};\n";
-                $code .= GenerateReflectOnlyCheck($attribute->extendedAttributes->{"ReflectOnly"}, "    ");
+                $code .= GenerateReflectOnlyCheck($attribute->extendedAttributes, "    ");
                 $getterExpression = "resultValue";
             }
             $code .= "    v8SetReturnValueString(info, ${getterExpression}, info.GetIsolate());\n";
             $code .= "}\n";
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
             $code .= "\n";
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
@@ skipping 4175 matching lines @@
     }
 
     # long long and unsigned long long are not representable in ECMAScript.
     if ($type eq "long long" or $type eq "unsigned long long" or $type eq "DOMTimeStamp") {
         return "${indent}v8SetReturnValue(${getCallbackInfo}, static_cast<double>($nativeValue));" if $isReturnValue;
         return "$indent$receiver v8::Number::New($getIsolate, static_cast<double>($nativeValue));";
     }
 
     if ($type eq "DOMString" && $extendedAttributes->{"ReflectOnly"}) {
         my $code = "${indent}String resultValue = ${nativeValue};\n";
-        $code .= GenerateReflectOnlyCheck($extendedAttributes->{"ReflectOnly"}, ${indent});
+        $code .= GenerateReflectOnlyCheck($extendedAttributes, ${indent});
         return "${code}${indent}v8SetReturnValueString(${getCallbackInfo}, resultValue, $getIsolate);" if $isReturnValue;
         return "${code}$indent$receiver resultValue";
     }
 
     my $conv = $extendedAttributes->{"TreatReturnedNullStringAs"};
     if (($type eq "DOMString" || IsEnumType($type)) && $isReturnValue) {
         my $functionSuffix = "";
         if (defined $conv) {
             if ($conv eq "Null") {
                 $functionSuffix = "OrNull";
@@ skipping 533 matching lines @@
             } else {
                 push(@checks, "    COMPILE_ASSERT($value == ${implClassName}::$name, TheValueOf${implClassName}_${name}DoesntMatchWithImplementation);\n");
             }
         }
     }
     return @checks;
 }
 
 sub GenerateReflectOnlyCheck
 {
-    my $knownValueString = shift;
+    my $extendedAttributes = shift;
     my $indent = shift;
 
+    my $knownValueString = $extendedAttributes->{"ReflectOnly"};
     my @knownValues = split(quotemeta("|"), $knownValueString);
 
+    my $missingValueDefault = $extendedAttributes->{"ReflectMissing"};
+    if ($missingValueDefault) {
+        if (!grep { $_ eq $missingValueDefault } @knownValues) {
+            die "Missing attribute value is not a known value " . $missingValueDefault;
+        }
+        $missingValueDefault = "resultValue = \"${missingValueDefault}\"";
+    } else {
+        $missingValueDefault = "";
+    }
+
+    my $invalidValueDefault = $extendedAttributes->{"ReflectInvalid"};
+    if ($invalidValueDefault) {
+        if (!grep { $_ eq $invalidValueDefault } @knownValues) {
+            die "Invalid attribute value is not a known value " . $invalidValueDefault;
+        }
+        $invalidValueDefault = "\"${invalidValueDefault}\"";
+    } else {
+        $invalidValueDefault = "\"\"";
+    }
+
     # Attribute is limited to only known values: check that the attribute
     # value is one of those..and if not, set it to the empty string.
     # ( http://www.whatwg.org/specs/web-apps/current-work/#limited-to-only-known-values )
     #
     my @normalizeAttributeCode = ();
     my $code = "";
     foreach my $knownValue (@knownValues) {
         push(@normalizeAttributeCode, "${indent}} else if (equalIgnoringCase(resultValue, \"$knownValue\")) {");
         push(@normalizeAttributeCode, "${indent}    resultValue = \"$knownValue\";");
     }
     my $normalizeAttributeValue = join("\n", @normalizeAttributeCode);
     $code .= <<END;
 ${indent}if (resultValue.isEmpty()) {
-${indent}    ;
+${indent}    $missingValueDefault;
 ${normalizeAttributeValue}
 ${indent}} else {
-${indent}    resultValue = "";
+${indent}    resultValue = $invalidValueDefault;
 ${indent}}
 END
         return "${code}";
 }
 
 sub ExtendedAttributeContains
 {
     my $extendedAttributeValue = shift;
     return 0 unless $extendedAttributeValue;
     my $keyword = shift;
@@ skipping 56 matching lines @@
 
     foreach my $parameter (@{$function->parameters}) {
         if ($parameter->type eq "SerializedScriptValue") {
             return 1;
         }
     }
     return 0;
 }
 
 1;