Changeset 206812 in webkit


Ignore:
Timestamp:
Oct 5, 2016 9:09:20 AM (8 years ago)
Author:
Chris Dumez
Message:

[Bindings] Declare dictionary / enumeration template specializations in the header
​https://bugs.webkit.org/show_bug.cgi?id=162929

Reviewed by Darin Adler.

Declare dictionary / enumeration template specializations in the header
so that:

  • They can be used from custom bindings code.
  • Dictionaries / enumerations can be used to their own IDL files to share them (Bug 162912).

No new tests, rebaselined bindings tests.

  • WebCore.xcodeproj/project.pbxproj:
  • bindings/generic/IDLTypes.h:
  • bindings/js/JSDOMConvert.h:
  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateInterface):
(GenerateEnumerationImplementationContent):
(GenerateEnumerationHeaderContent):
(GenerateDictionaryHeaderContent):
(GenerateHeader):
(GenerateCallbackHeader):
(GenerateCallbackImplementation):
(GenerateDefaultValue): Deleted.
(GenerateDictionaryImplementationContent): Deleted.
(GenerateParametersCheck): Deleted.

  • bindings/scripts/test/JS/JSTestObj.cpp:
  • bindings/scripts/test/JS/JSTestObj.h:
Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r206811 r206812  
     12016-10-05  Chris Dumez  <cdumez@apple.com>
     2
     3        [Bindings] Declare dictionary / enumeration template specializations in the header
     4        https://bugs.webkit.org/show_bug.cgi?id=162929
     5
     6        Reviewed by Darin Adler.
     7
     8        Declare dictionary / enumeration template specializations in the header
     9        so that:
     10        - They can be used from custom bindings code.
     11        - Dictionaries / enumerations can be used to their own IDL files to
     12          share them (Bug 162912).
     13
     14        No new tests, rebaselined bindings tests.
     15
     16        * WebCore.xcodeproj/project.pbxproj:
     17        * bindings/generic/IDLTypes.h:
     18        * bindings/js/JSDOMConvert.h:
     19        * bindings/scripts/CodeGeneratorJS.pm:
     20        (GenerateInterface):
     21        (GenerateEnumerationImplementationContent):
     22        (GenerateEnumerationHeaderContent):
     23        (GenerateDictionaryHeaderContent):
     24        (GenerateHeader):
     25        (GenerateCallbackHeader):
     26        (GenerateCallbackImplementation):
     27        (GenerateDefaultValue): Deleted.
     28        (GenerateDictionaryImplementationContent): Deleted.
     29        (GenerateParametersCheck): Deleted.
     30        * bindings/scripts/test/JS/JSTestObj.cpp:
     31        * bindings/scripts/test/JS/JSTestObj.h:
     32
    1332016-10-05  Zan Dobersek  <zdobersek@igalia.com>
    234

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r206795 r206812  
    27732773                7C9DBFED1A9C49B1000D6B25 /* JSHTMLAttachmentElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7C9DBFEB1A9C49B1000D6B25 /* JSHTMLAttachmentElement.cpp */; };
    27742774                7C9DBFEE1A9C49B1000D6B25 /* JSHTMLAttachmentElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C9DBFEC1A9C49B1000D6B25 /* JSHTMLAttachmentElement.h */; };
    2775                 7CC16FFB1D77375300CE0877 /* IDLTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 7CC16FFA1D77375300CE0877 /* IDLTypes.h */; };
     2775                7CC16FFB1D77375300CE0877 /* IDLTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 7CC16FFA1D77375300CE0877 /* IDLTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
    27762776                7CC289DF1AA0FE5D009A9CE3 /* URLRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = CDEE393817974274001D7580 /* URLRegistry.h */; settings = {ATTRIBUTES = (Private, ); }; };
    27772777                7CC564B818BABEA6001B9652 /* TelephoneNumberDetector.h in Headers */ = {isa = PBXBuildFile; fileRef = 7CC564B618BABEA6001B9652 /* TelephoneNumberDetector.h */; };
    … …  
    31003100                9307F1D70AF2D59000DBA31A /* HitTestResult.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9307F1D50AF2D59000DBA31A /* HitTestResult.cpp */; };
    31013101                9307F1D80AF2D59000DBA31A /* HitTestResult.h in Headers */ = {isa = PBXBuildFile; fileRef = 9307F1D60AF2D59000DBA31A /* HitTestResult.h */; settings = {ATTRIBUTES = (Private, ); }; };
    3102                 930841341CDDB15500B0958C /* JSDOMConvert.h in Headers */ = {isa = PBXBuildFile; fileRef = 930841331CDDB15500B0958C /* JSDOMConvert.h */; };
     3102                930841341CDDB15500B0958C /* JSDOMConvert.h in Headers */ = {isa = PBXBuildFile; fileRef = 930841331CDDB15500B0958C /* JSDOMConvert.h */; settings = {ATTRIBUTES = (Private, ); }; };
    31033103                930908910AF7EDE40081DF01 /* HitTestRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 930908900AF7EDE40081DF01 /* HitTestRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    31043104                930C90DD19CF965300D6C21A /* InlineIterator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 930C90DC19CF965300D6C21A /* InlineIterator.cpp */; };

  • trunk/Source/WebCore/bindings/generic/IDLTypes.h

    r206691 r206812  
    2828#include <wtf/Brigand.h>
    2929#include <wtf/StdLibExtras.h>
     30#include <wtf/text/WTFString.h>
    3031
    3132namespace JSC {

  • trunk/Source/WebCore/bindings/js/JSDOMConvert.h

    r206766 r206812  
    409409};
    410410
     411// Used for IDL enumerations.
     412template<typename T> Optional<T> parse(JSC::ExecState&, JSC::JSValue);
     413template<typename T> const char* expectedEnumerationValues();
     414
    411415} // namespace WebCore

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r206776 r206812  
    129129
    130130    if ($interface->isCallback) {
    131         $object->GenerateCallbackHeader($interface);
     131        $object->GenerateCallbackHeader($interface, $enumerations, $dictionaries);
    132132        $object->GenerateCallbackImplementation($interface, $enumerations, $dictionaries);
    133133    } else {
    134         $object->GenerateHeader($interface);
     134        $object->GenerateHeader($interface, $enumerations, $dictionaries);
    135135        $object->GenerateImplementation($interface, $enumerations, $dictionaries);
    136136    }
    … …  
    809809    return "" unless @$enumerations;
    810810
    811     # FIXME: Could optimize this to only generate the parts of each enumeration that are actually
    812     # used, which would require iterating over everything in the interface.
    813 
    814811    my $result = "";
    815 
    816     $result .= "template<typename T> Optional<T> parse(ExecState&, JSValue);\n";
    817     $result .= "template<typename T> const char* expectedEnumerationValues();\n\n";
    818 
    819812    foreach my $enumeration (@$enumerations) {
    820813        my $name = $enumeration->name;
    … …  
    827820        my $conditionalString = $codeGenerator->GenerateConditionalString($enumeration);
    828821        $result .= "#if ${conditionalString}\n\n" if $conditionalString;
    829 
    830         # Declare this instead of using "static" because it may be unused and we don't want warnings about that.
    831         $result .= "JSString* jsStringWithCache(ExecState*, $className);\n\n";
    832822
    833823        # Take an ExecState* instead of an ExecState& to match the jsStringWithCache from JSString.h.
    … …  
    856846        $result .= "}\n\n";
    857847
    858         $result .= "template<> struct JSValueTraits<$className> {\n";
    859         $result .= "    static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, $className value) { return jsStringWithCache(state, value); }\n";
    860         $result .= "};\n\n";
    861 
    862848        # FIXME: Change to take VM& instead of ExecState&.
    863849        # FIXME: Consider using toStringOrNull to make exception checking faster.
    … …  
    893879        $result .= "}\n\n";
    894880
    895         $result .= "template<> inline const char* expectedEnumerationValues<$className>()\n";
     881        $result .= "template<> const char* expectedEnumerationValues<$className>()\n";
    896882        $result .= "{\n";
    897883        $result .= "    return \"\\\"" . join ("\\\", \\\"", @{$enumeration->values}) . "\\\"\";\n";
    898884        $result .= "}\n\n";
     885
     886        $result .= "#endif\n\n" if $conditionalString;
     887    }
     888    return $result;
     889}
     890
     891sub GenerateEnumerationHeaderContent
     892{
     893    my ($interface, $enumerations) = @_;
     894
     895    return "" unless @$enumerations;
     896
     897    # FIXME: Could optimize this to only generate the parts of each enumeration that are actually
     898    # used, which would require iterating over everything in the interface.
     899
     900    $headerIncludes{"JSDOMConvert.h"} = 1;
     901
     902    my $result = "";
     903
     904    foreach my $enumeration (@$enumerations) {
     905        my $name = $enumeration->name;
     906
     907        my $className = GetEnumerationClassName($interface, $name);
     908
     909        my $conditionalString = $codeGenerator->GenerateConditionalString($enumeration);
     910        $result .= "#if ${conditionalString}\n\n" if $conditionalString;
     911
     912        $result .= "JSC::JSString* jsStringWithCache(JSC::ExecState*, $className);\n\n";
     913
     914        $result .= "template<> struct JSValueTraits<$className> {\n";
     915        $result .= "    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, $className value) { return jsStringWithCache(state, value); }\n";
     916        $result .= "};\n\n";
     917
     918        $result .= "template<> Optional<$className> parse<$className>(JSC::ExecState&, JSC::JSValue);\n";
     919        $result .= "template<> $className convert<$className>(JSC::ExecState&, JSC::JSValue);\n";
     920        $result .= "template<> const char* expectedEnumerationValues<$className>();\n\n";
    899921
    900922        $result .= "#endif\n\n" if $conditionalString;
    … …  
    950972    return ", " . GetIntegerConversionConfiguration($member) if $codeGenerator->IsIntegerType($member->type);
    951973    return "";
     974}
     975
     976sub GenerateDictionaryHeaderContent
     977{
     978    my ($interface, $allDictionaries) = @_;
     979
     980    return "" unless @$allDictionaries;
     981
     982    $headerIncludes{"JSDOMConvert.h"} = 1;
     983
     984    my $result = "";
     985    foreach my $dictionary (@$allDictionaries) {
     986        my $name = $dictionary->name;
     987
     988        my $conditionalString = $codeGenerator->GenerateConditionalString($dictionary);
     989        $result .= "#if ${conditionalString}\n\n" if $conditionalString;
     990
     991        $headerIncludes{$interface->name . ".h"} = 1;
     992
     993        my $className = GetDictionaryClassName($interface, $name);
     994        $result .= "template<> Optional<$className> convertDictionary<$className>(JSC::ExecState&, JSC::JSValue);\n\n";
     995
     996        $result .= "#endif\n\n" if $conditionalString;
     997    }
     998    return $result;
    952999}
    9531000
    … …  
    10801127sub GenerateHeader
    10811128{
    1082     my ($object, $interface) = @_;
     1129    my ($object, $interface, $enumerations, $dictionaries) = @_;
    10831130
    10841131    my $interfaceName = $interface->name;
    … …  
    15711618        push(@headerContent, "};\n");
    15721619    }
     1620
     1621    push(@headerContent, GenerateEnumerationHeaderContent($interface, $enumerations));
     1622    push(@headerContent, GenerateDictionaryHeaderContent($interface, $dictionaries));
    15731623
    15741624    my $conditionalString = $codeGenerator->GenerateConditionalString($interface);
    … …  
    41274177sub GenerateCallbackHeader
    41284178{
    4129     my ($object, $interface) = @_;
     4179    my ($object, $interface, $enumerations, $dictionaries) = @_;
    41304180
    41314181    my $interfaceName = $interface->name;
    … …  
    41864236    push(@headerContent, "inline JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, $interfaceName* impl) { return impl ? toJS(state, globalObject, *impl) : JSC::jsNull(); }\n\n");
    41874237
     4238    push(@headerContent, GenerateEnumerationHeaderContent($interface, $enumerations));
     4239    push(@headerContent, GenerateDictionaryHeaderContent($interface, $dictionaries));
     4240
    41884241    push(@headerContent, "} // namespace WebCore\n");
    41894242
    … …  
    41944247sub GenerateCallbackImplementation
    41954248{
    4196     my ($object, $interface, $enumerations) = @_;
     4249    my ($object, $interface, $enumerations, $dictionaries) = @_;
    41974250
    41984251    my $interfaceName = $interface->name;
    … …  
    42124265
    42134266    push(@implContent, GenerateEnumerationImplementationContent($interface, $enumerations));
     4267    push(@implContent, GenerateDictionaryImplementationContent($interface, $dictionaries));
    42144268
    42154269    # Constructor

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r206776 r206812  
    3535#include "JSDOMBinding.h"
    3636#include "JSDOMConstructor.h"
    37 #include "JSDOMConvert.h"
    3837#include "JSDOMIterator.h"
    3938#include "JSDOMPromise.h"
    … …  
    9392namespace WebCore {
    9493
    95 template<typename T> Optional<T> parse(ExecState&, JSValue);
    96 template<typename T> const char* expectedEnumerationValues();
    97 
    98 JSString* jsStringWithCache(ExecState*, TestObj::EnumType);
    99 
    10094JSString* jsStringWithCache(ExecState* state, TestObj::EnumType enumerationValue)
    10195{
    … …  
    114108}
    115109
    116 template<> struct JSValueTraits<TestObj::EnumType> {
    117     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumType value) { return jsStringWithCache(state, value); }
    118 };
    119 
    120110template<> Optional<TestObj::EnumType> parse<TestObj::EnumType>(ExecState& state, JSValue value)
    121111{
    … …  
    144134}
    145135
    146 template<> inline const char* expectedEnumerationValues<TestObj::EnumType>()
     136template<> const char* expectedEnumerationValues<TestObj::EnumType>()
    147137{
    148138    return "\"\", \"enumValue1\", \"EnumValue2\", \"EnumValue3\"";
    149139}
    150 
    151 JSString* jsStringWithCache(ExecState*, TestObj::Optional);
    152140
    153141JSString* jsStringWithCache(ExecState* state, TestObj::Optional enumerationValue)
    … …  
    167155}
    168156
    169 template<> struct JSValueTraits<TestObj::Optional> {
    170     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Optional value) { return jsStringWithCache(state, value); }
    171 };
    172 
    173157template<> Optional<TestObj::Optional> parse<TestObj::Optional>(ExecState& state, JSValue value)
    174158{
    … …  
    197181}
    198182
    199 template<> inline const char* expectedEnumerationValues<TestObj::Optional>()
     183template<> const char* expectedEnumerationValues<TestObj::Optional>()
    200184{
    201185    return "\"\", \"OptionalValue1\", \"OptionalValue2\", \"OptionalValue3\"";
    202186}
    203 
    204 JSString* jsStringWithCache(ExecState*, AlternateEnumName);
    205187
    206188JSString* jsStringWithCache(ExecState* state, AlternateEnumName enumerationValue)
    … …  
    216198}
    217199
    218 template<> struct JSValueTraits<AlternateEnumName> {
    219     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, AlternateEnumName value) { return jsStringWithCache(state, value); }
    220 };
    221 
    222200template<> Optional<AlternateEnumName> parse<AlternateEnumName>(ExecState& state, JSValue value)
    223201{
    … …  
    242220}
    243221
    244 template<> inline const char* expectedEnumerationValues<AlternateEnumName>()
     222template<> const char* expectedEnumerationValues<AlternateEnumName>()
    245223{
    246224    return "\"enumValue1\", \"EnumValue2\"";
    … …  
    248226
    249227#if ENABLE(Condition1)
    250 
    251 JSString* jsStringWithCache(ExecState*, TestObj::EnumA);
    252228
    253229JSString* jsStringWithCache(ExecState* state, TestObj::EnumA enumerationValue)
    … …  
    261237}
    262238
    263 template<> struct JSValueTraits<TestObj::EnumA> {
    264     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumA value) { return jsStringWithCache(state, value); }
    265 };
    266 
    267239template<> Optional<TestObj::EnumA> parse<TestObj::EnumA>(ExecState& state, JSValue value)
    268240{
    … …  
    285257}
    286258
    287 template<> inline const char* expectedEnumerationValues<TestObj::EnumA>()
     259template<> const char* expectedEnumerationValues<TestObj::EnumA>()
    288260{
    289261    return "\"A\"";
    … …  
    293265
    294266#if ENABLE(Condition1) && ENABLE(Condition2)
    295 
    296 JSString* jsStringWithCache(ExecState*, TestObj::EnumB);
    297267
    298268JSString* jsStringWithCache(ExecState* state, TestObj::EnumB enumerationValue)
    … …  
    306276}
    307277
    308 template<> struct JSValueTraits<TestObj::EnumB> {
    309     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumB value) { return jsStringWithCache(state, value); }
    310 };
    311 
    312278template<> Optional<TestObj::EnumB> parse<TestObj::EnumB>(ExecState& state, JSValue value)
    313279{
    … …  
    330296}
    331297
    332 template<> inline const char* expectedEnumerationValues<TestObj::EnumB>()
     298template<> const char* expectedEnumerationValues<TestObj::EnumB>()
    333299{
    334300    return "\"B\"";
    … …  
    338304
    339305#if ENABLE(Condition1) || ENABLE(Condition2)
    340 
    341 JSString* jsStringWithCache(ExecState*, TestObj::EnumC);
    342306
    343307JSString* jsStringWithCache(ExecState* state, TestObj::EnumC enumerationValue)
    … …  
    351315}
    352316
    353 template<> struct JSValueTraits<TestObj::EnumC> {
    354     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumC value) { return jsStringWithCache(state, value); }
    355 };
    356 
    357317template<> Optional<TestObj::EnumC> parse<TestObj::EnumC>(ExecState& state, JSValue value)
    358318{
    … …  
    375335}
    376336
    377 template<> inline const char* expectedEnumerationValues<TestObj::EnumC>()
     337template<> const char* expectedEnumerationValues<TestObj::EnumC>()
    378338{
    379339    return "\"C\"";
    … …  
    381341
    382342#endif
    383 
    384 JSString* jsStringWithCache(ExecState*, TestObj::Kind);
    385343
    386344JSString* jsStringWithCache(ExecState* state, TestObj::Kind enumerationValue)
    … …  
    396354}
    397355
    398 template<> struct JSValueTraits<TestObj::Kind> {
    399     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Kind value) { return jsStringWithCache(state, value); }
    400 };
    401 
    402356template<> Optional<TestObj::Kind> parse<TestObj::Kind>(ExecState& state, JSValue value)
    403357{
    … …  
    422376}
    423377
    424 template<> inline const char* expectedEnumerationValues<TestObj::Kind>()
     378template<> const char* expectedEnumerationValues<TestObj::Kind>()
    425379{
    426380    return "\"quick\", \"dead\"";
    427381}
    428 
    429 JSString* jsStringWithCache(ExecState*, TestObj::Size);
    430382
    431383JSString* jsStringWithCache(ExecState* state, TestObj::Size enumerationValue)
    … …  
    441393}
    442394
    443 template<> struct JSValueTraits<TestObj::Size> {
    444     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Size value) { return jsStringWithCache(state, value); }
    445 };
    446 
    447395template<> Optional<TestObj::Size> parse<TestObj::Size>(ExecState& state, JSValue value)
    448396{
    … …  
    467415}
    468416
    469 template<> inline const char* expectedEnumerationValues<TestObj::Size>()
     417template<> const char* expectedEnumerationValues<TestObj::Size>()
    470418{
    471419    return "\"small\", \"much-much-larger\"";
    472420}
    473 
    474 JSString* jsStringWithCache(ExecState*, TestObj::Confidence);
    475421
    476422JSString* jsStringWithCache(ExecState* state, TestObj::Confidence enumerationValue)
    … …  
    486432}
    487433
    488 template<> struct JSValueTraits<TestObj::Confidence> {
    489     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Confidence value) { return jsStringWithCache(state, value); }
    490 };
    491 
    492434template<> Optional<TestObj::Confidence> parse<TestObj::Confidence>(ExecState& state, JSValue value)
    493435{
    … …  
    512454}
    513455
    514 template<> inline const char* expectedEnumerationValues<TestObj::Confidence>()
     456template<> const char* expectedEnumerationValues<TestObj::Confidence>()
    515457{
    516458    return "\"high\", \"kinda-low\"";

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.h

    r206723 r206812  
    2121#pragma once
    2222
     23#include "JSDOMConvert.h"
    2324#include "JSDOMWrapper.h"
    2425#include "TestObj.h"
    … …  
    105106    using WrapperClass = JSTestObj;
    106107};
     108JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::EnumType);
     109
     110template<> struct JSValueTraits<TestObj::EnumType> {
     111    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::EnumType value) { return jsStringWithCache(state, value); }
     112};
     113
     114template<> Optional<TestObj::EnumType> parse<TestObj::EnumType>(JSC::ExecState&, JSC::JSValue);
     115template<> TestObj::EnumType convert<TestObj::EnumType>(JSC::ExecState&, JSC::JSValue);
     116template<> const char* expectedEnumerationValues<TestObj::EnumType>();
     117
     118JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::Optional);
     119
     120template<> struct JSValueTraits<TestObj::Optional> {
     121    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::Optional value) { return jsStringWithCache(state, value); }
     122};
     123
     124template<> Optional<TestObj::Optional> parse<TestObj::Optional>(JSC::ExecState&, JSC::JSValue);
     125template<> TestObj::Optional convert<TestObj::Optional>(JSC::ExecState&, JSC::JSValue);
     126template<> const char* expectedEnumerationValues<TestObj::Optional>();
     127
     128JSC::JSString* jsStringWithCache(JSC::ExecState*, AlternateEnumName);
     129
     130template<> struct JSValueTraits<AlternateEnumName> {
     131    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, AlternateEnumName value) { return jsStringWithCache(state, value); }
     132};
     133
     134template<> Optional<AlternateEnumName> parse<AlternateEnumName>(JSC::ExecState&, JSC::JSValue);
     135template<> AlternateEnumName convert<AlternateEnumName>(JSC::ExecState&, JSC::JSValue);
     136template<> const char* expectedEnumerationValues<AlternateEnumName>();
     137
     138#if ENABLE(Condition1)
     139
     140JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::EnumA);
     141
     142template<> struct JSValueTraits<TestObj::EnumA> {
     143    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::EnumA value) { return jsStringWithCache(state, value); }
     144};
     145
     146template<> Optional<TestObj::EnumA> parse<TestObj::EnumA>(JSC::ExecState&, JSC::JSValue);
     147template<> TestObj::EnumA convert<TestObj::EnumA>(JSC::ExecState&, JSC::JSValue);
     148template<> const char* expectedEnumerationValues<TestObj::EnumA>();
     149
     150#endif
     151
     152#if ENABLE(Condition1) && ENABLE(Condition2)
     153
     154JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::EnumB);
     155
     156template<> struct JSValueTraits<TestObj::EnumB> {
     157    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::EnumB value) { return jsStringWithCache(state, value); }
     158};
     159
     160template<> Optional<TestObj::EnumB> parse<TestObj::EnumB>(JSC::ExecState&, JSC::JSValue);
     161template<> TestObj::EnumB convert<TestObj::EnumB>(JSC::ExecState&, JSC::JSValue);
     162template<> const char* expectedEnumerationValues<TestObj::EnumB>();
     163
     164#endif
     165
     166#if ENABLE(Condition1) || ENABLE(Condition2)
     167
     168JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::EnumC);
     169
     170template<> struct JSValueTraits<TestObj::EnumC> {
     171    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::EnumC value) { return jsStringWithCache(state, value); }
     172};
     173
     174template<> Optional<TestObj::EnumC> parse<TestObj::EnumC>(JSC::ExecState&, JSC::JSValue);
     175template<> TestObj::EnumC convert<TestObj::EnumC>(JSC::ExecState&, JSC::JSValue);
     176template<> const char* expectedEnumerationValues<TestObj::EnumC>();
     177
     178#endif
     179
     180JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::Kind);
     181
     182template<> struct JSValueTraits<TestObj::Kind> {
     183    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::Kind value) { return jsStringWithCache(state, value); }
     184};
     185
     186template<> Optional<TestObj::Kind> parse<TestObj::Kind>(JSC::ExecState&, JSC::JSValue);
     187template<> TestObj::Kind convert<TestObj::Kind>(JSC::ExecState&, JSC::JSValue);
     188template<> const char* expectedEnumerationValues<TestObj::Kind>();
     189
     190JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::Size);
     191
     192template<> struct JSValueTraits<TestObj::Size> {
     193    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::Size value) { return jsStringWithCache(state, value); }
     194};
     195
     196template<> Optional<TestObj::Size> parse<TestObj::Size>(JSC::ExecState&, JSC::JSValue);
     197template<> TestObj::Size convert<TestObj::Size>(JSC::ExecState&, JSC::JSValue);
     198template<> const char* expectedEnumerationValues<TestObj::Size>();
     199
     200JSC::JSString* jsStringWithCache(JSC::ExecState*, TestObj::Confidence);
     201
     202template<> struct JSValueTraits<TestObj::Confidence> {
     203    static JSC::JSString* arrayJSValue(JSC::ExecState* state, JSDOMGlobalObject*, TestObj::Confidence value) { return jsStringWithCache(state, value); }
     204};
     205
     206template<> Optional<TestObj::Confidence> parse<TestObj::Confidence>(JSC::ExecState&, JSC::JSValue);
     207template<> TestObj::Confidence convert<TestObj::Confidence>(JSC::ExecState&, JSC::JSValue);
     208template<> const char* expectedEnumerationValues<TestObj::Confidence>();
     209
     210template<> Optional<TestObj::Dictionary> convertDictionary<TestObj::Dictionary>(JSC::ExecState&, JSC::JSValue);
     211
     212template<> Optional<TestObj::DictionaryThatShouldNotTolerateNull> convertDictionary<TestObj::DictionaryThatShouldNotTolerateNull>(JSC::ExecState&, JSC::JSValue);
     213
     214template<> Optional<TestObj::DictionaryThatShouldTolerateNull> convertDictionary<TestObj::DictionaryThatShouldTolerateNull>(JSC::ExecState&, JSC::JSValue);
     215
     216template<> Optional<AlternateDictionaryName> convertDictionary<AlternateDictionaryName>(JSC::ExecState&, JSC::JSValue);
     217
     218template<> Optional<TestObj::ParentDictionary> convertDictionary<TestObj::ParentDictionary>(JSC::ExecState&, JSC::JSValue);
     219
     220template<> Optional<TestObj::ChildDictionary> convertDictionary<TestObj::ChildDictionary>(JSC::ExecState&, JSC::JSValue);
     221
    107222
    108223} // namespace WebCore
Note: See TracChangeset for help on using the changeset viewer.