Attachment #244668 for bug #136311

View Details Raw Unified Return to Bug 136311

| Differences between



2015-01-14  Brian J. Burg  <burg@cs.washington.edu>

        Web Replay: only generate EncodingTraits for enums defined in the target framework
        https://bugs.webkit.org/show_bug.cgi?id=136311

        Reviewed by NOBODY (OOPS!).

        Don't generate EncodingTraits for enums unless they belong to the target framework.
        Otherwise, enums used in multiple frameworks' inputs cannot be unambiguously encoded/decoded
        because they will have more than one generated implementation.

        For now, some type definitions will be duplicated between JSON specification files.
        This will be fixed in a follow-up bug that teaches the generator about supplemental specifications.

        Use Type.encoding_type_argument in more places, and add the export macro for WebCore.

        Adjust some tests so that enum coverage is preserved by moving the enum types into "Test"
        (the target framework for tests). 

        * replay/JSInputs.json: Copy the InputQueue enum to here. It will be removed from WebInputs.json
        in a future patch when supplemental input specifications can be read by the generator.
        * replay/scripts/CodeGeneratorReplayInputs.py:
        (Generator.generate_header): Selectively generate traits.
        (Generator.generate_implementation):
        (Generator.generate_enum_trait_implementation): add WEBCORE_EXPORT macro to enum encoding traits.
        * replay/scripts/CodeGeneratorReplayInputsTemplates.py:
        * replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.cpp:
        * replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp:
        * replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.cpp:
        * replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp:
        * replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-input-with-guard.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-input-with-vector-members.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-inputs-with-flags.json-TestReplayInputs.h:
        * replay/scripts/tests/expected/generate-memoized-type-modes.json-TestReplayInputs.h:
        * replay/scripts/tests/generate-enum-encoding-helpers.json:
        * replay/scripts/tests/generate-enum-with-guard.json: Include enums that are and are not generated.
        * replay/scripts/tests/generate-enums-with-same-base-name.json:

2015-01-14  Matthew Mirman  <mmirman@apple.com>

        Removed accidental commit of "invalid_array.js" 

Lines 3-8 a/Source/JavaScriptCore/replay/JSInputs.json_sec1
- a/Source/JavaScriptCore/replay/JSInputs.json +9 lines
3	"Global": [	3	"Global": [
4	{ "name": "double", "mode": "SCALAR" },	4	{ "name": "double", "mode": "SCALAR" },
5	{ "name": "uint64_t", "mode": "SCALAR" }	5	{ "name": "uint64_t", "mode": "SCALAR" }
		6	],
		7
		8	"JavaScriptCore": [
		9	{
		10	"name": "InputQueue", "mode": "SCALAR", "storage": "uint8_t",
		11	"flags": ["ENUM_CLASS"],
		12	"values": ["EventLoopInput", "LoaderMemoizedData", "ScriptMemoizedData", "Count"],
		13	"header": "replay/NondeterministicInput.h"
		14	}
6	]	15	]
7	},	16	},
8		17

Lines 109-119 FRAMEWORK_CONFIG_MAP = { a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec1
- a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py -4 / +17 lines
109	"WebCore": {	109	"WebCore": {
110	"prefix": "Web",	110	"prefix": "Web",
111	"namespace": "WebCore",	111	"namespace": "WebCore",
		112	"exportMacro": "WEBCORE_EXPORT"
112	},	113	},
113	# Used for bindings tests.	114	# Used for bindings tests.
114	"Test": {	115	"Test": {
115	"prefix": "Test",	116	"prefix": "Test",
116	"namespace": "Test",	117	"namespace": "Test",
		118	"exportMacro": "TEST_EXPORT_MACRO"
117	}	119	}
118	}	120	}
119		121
Lines 584-589 class Generator: a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec2
584	implementation_file.close()	586	implementation_file.close()
585		587
586	def generate_header(self):	588	def generate_header(self):
		589	enums_to_generate = filter(lambda enum: enum.framework is self.target_framework, self._model.enum_types())
		590
587	template_arguments = {	591	template_arguments = {
588	'licenseBlock': self.generate_license(),	592	'licenseBlock': self.generate_license(),
589	'headerGuard': re.sub('[-./]', '_', self.output_filename() + ".h"),	593	'headerGuard': re.sub('[-./]', '_', self.output_filename() + ".h"),
Lines 596-608 class Generator: a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec3
596	'inputForwardDeclarations': "\n".join([wrap_with_guard("class %s;", _input.guard) % _input.name for _input in self._model.inputs]),	600	'inputForwardDeclarations': "\n".join([wrap_with_guard("class %s;", _input.guard) % _input.name for _input in self._model.inputs]),
597	'inputClassDeclarations': "\n\n".join([self.generate_class_declaration(_input) for _input in self._model.inputs]),	601	'inputClassDeclarations': "\n\n".join([self.generate_class_declaration(_input) for _input in self._model.inputs]),
598	'inputTraitDeclarations': "\n\n".join([self.generate_input_trait_declaration(_input) for _input in self._model.inputs]),	602	'inputTraitDeclarations': "\n\n".join([self.generate_input_trait_declaration(_input) for _input in self._model.inputs]),
599	'enumTraitDeclarations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_declaration(_type), _type.guard) for _type in self._model.enum_types()]),	603	'enumTraitDeclarations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_declaration(_type), _type.guard) for _type in enums_to_generate]),
600	'forEachMacro': self.generate_for_each_macro(),	604	'forEachMacro': self.generate_for_each_macro(),
601	}	605	}
602		606
603	return Template(Templates.HeaderSkeleton).substitute(template_arguments)	607	return Template(Templates.HeaderSkeleton).substitute(template_arguments)
604		608
605	def generate_implementation(self):	609	def generate_implementation(self):
		610	enums_to_generate = filter(lambda enum: enum.framework is self.target_framework, self._model.enum_types())
		611
606	template_arguments = {	612	template_arguments = {
607	'licenseBlock': self.generate_license(),	613	'licenseBlock': self.generate_license(),
608	'filename': self.output_filename(),	614	'filename': self.output_filename(),
Lines 612-618 class Generator: a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec4
612	'includes': self.generate_includes(defaults=self.setting('implIncludes'), includes_for_types=True),	618	'includes': self.generate_includes(defaults=self.setting('implIncludes'), includes_for_types=True),
613	'inputClassImplementations': "\n\n".join([self.generate_class_implementation(_input) for _input in self._model.inputs]),	619	'inputClassImplementations': "\n\n".join([self.generate_class_implementation(_input) for _input in self._model.inputs]),
614	'inputTraitImplementations': "\n\n".join([self.generate_input_trait_implementation(_input) for _input in self._model.inputs]),	620	'inputTraitImplementations': "\n\n".join([self.generate_input_trait_implementation(_input) for _input in self._model.inputs]),
615	'enumTraitImplementations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_implementation(_type), _type.guard) for _type in self._model.enum_types()]),	621	'enumTraitImplementations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_implementation(_type), _type.guard) for _type in enums_to_generate]),
616	}	622	}
617		623
618	return Template(Templates.ImplementationSkeleton).substitute(template_arguments)	624	return Template(Templates.ImplementationSkeleton).substitute(template_arguments)
Lines 767-776 class Generator: a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec5
767	return wrap_with_guard(Template(Templates.InputTraitsDeclaration).substitute(template_arguments), _input.guard)	773	return wrap_with_guard(Template(Templates.InputTraitsDeclaration).substitute(template_arguments), _input.guard)
768		774
769	def generate_enum_trait_declaration(self, _type):	775	def generate_enum_trait_declaration(self, _type):
		776	decl_type = ['struct']
		777	if len(self.setting('exportMacro')) > 0:
		778	decl_type.append(self.setting('exportMacro'))
		779
770	should_qualify_type = _type.framework != self.traits_framework	780	should_qualify_type = _type.framework != self.traits_framework
771	template = Templates.EnumTraitDeclaration if _type.is_enum() else Templates.EnumClassTraitDeclaration	781	template = Templates.EnumTraitDeclaration if _type.is_enum() else Templates.EnumClassTraitDeclaration
772	template_arguments = {	782	template_arguments = {
773	'enumName': _type.type_name(qualified=should_qualify_type),	783	'encodingTypeArgument': _type.encoding_type_argument(qualified=should_qualify_type),
		784	'enumType': _type.type_name(qualified=should_qualify_type),
		785	'structOrClass': " ".join(decl_type)
774	}	786	}
775	return Template(template).substitute(template_arguments)	787	return Template(template).substitute(template_arguments)
776		788
Lines 858-864 class Generator: a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputs.py_sec6
858	decodeLines.append(wrap_with_guard("\n".join(guardedLines), guard))	870	decodeLines.append(wrap_with_guard("\n".join(guardedLines), guard))
859		871
860	template_arguments = {	872	template_arguments = {
861	'enumName': _type.type_name(qualified=should_qualify_type),	873	'encodingTypeArgument': _type.encoding_type_argument(qualified=should_qualify_type),
		874	'enumType': _type.type_name(qualified=should_qualify_type),
862	'encodeCases': "\n".join(encodeLines),	875	'encodeCases': "\n".join(encodeLines),
863	'decodeCases': "\n".join(decodeLines)	876	'decodeCases': "\n".join(decodeLines)
864	}	877	}



};""")

    EnumTraitDeclaration = (
    """template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
    typedef ${enumType} DecodedType;

    static EncodedValue encodeValue(const ${enumType}& value);
    static bool decodeValue(EncodedValue&, ${enumType}& value);
};""")

    EnumClassTraitDeclaration = (
    """template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
    typedef ${enumType} DecodedType;

    static EncodedValue encodeValue(const ${enumType}& value);
    static bool decodeValue(EncodedValue&, ${enumType}& value);
};""")

    InputClassDeclaration = (

}""")

    EnumClassTraitImplementation = (
    """EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
{
    switch (enumValue) {
${encodeCases}

    }
}

bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
{
    String enumString = encodedValue.convertTo<String>();
${decodeCases}

    }""")

    EnumTraitImplementation = (
    """EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
${encodeCases}
    return encodedValue;
}

bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))



    input = std::make_unique<Test::SavedMouseButton>(button);
    return true;
}
EncodedValue EncodingTraits<WebCore::MouseButton>::encodeValue(const WebCore::MouseButton& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & WebCore::NoButton) {
        encodedValue.append<String>(ASCIILiteral("NoButton"));
        if (enumValue == WebCore::NoButton)
            return encodedValue;
    }
    if (enumValue & WebCore::LeftButton) {
        encodedValue.append<String>(ASCIILiteral("LeftButton"));
        if (enumValue == WebCore::LeftButton)
            return encodedValue;
    }
    if (enumValue & WebCore::MiddleButton) {
        encodedValue.append<String>(ASCIILiteral("MiddleButton"));
        if (enumValue == WebCore::MiddleButton)
            return encodedValue;
    }
    if (enumValue & WebCore::RightButton) {
        encodedValue.append<String>(ASCIILiteral("RightButton"));
        if (enumValue == WebCore::RightButton)
            return encodedValue;
    }
#if ENABLE(SIDE_BUTTONS)
    if (enumValue & WebCore::LeftSideButton) {
        encodedValue.append<String>(ASCIILiteral("LeftSideButton"));
        if (enumValue == WebCore::LeftSideButton)
            return encodedValue;
    }
    if (enumValue & WebCore::RightSideButton) {
        encodedValue.append<String>(ASCIILiteral("RightSideButton"));
        if (enumValue == WebCore::RightSideButton)
            return encodedValue;
    }
#endif // ENABLE(SIDE_BUTTONS)
#if PLATFORM(WINDOWS)
    if (enumValue & WebCore::WindowsButton) {
        encodedValue.append<String>(ASCIILiteral("WindowsButton"));
        if (enumValue == WebCore::WindowsButton)
            return encodedValue;
    }
#endif // PLATFORM(WINDOWS)
    return encodedValue;
}

bool EncodingTraits<WebCore::MouseButton>::decodeValue(EncodedValue& encodedValue, WebCore::MouseButton& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
        return false;

    for (const String& enumString : enumStrings) {
        if (enumString == "NoButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::NoButton);
        else if (enumString == "LeftButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::LeftButton);
        else if (enumString == "MiddleButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::MiddleButton);
        else if (enumString == "RightButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::RightButton);
#if ENABLE(SIDE_BUTTONS)
        if (enumString == "LeftSideButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::LeftSideButton);
        else if (enumString == "RightSideButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::RightSideButton);
#endif // ENABLE(SIDE_BUTTONS)
#if PLATFORM(WINDOWS)
        if (enumString == "WindowsButton")
            enumValue = static_cast<WebCore::MouseButton>(enumValue | WebCore::WindowsButton);
#endif // PLATFORM(WINDOWS)
    }

    return true;
}
} // namespace JSC

#endif // ENABLE(WEB_REPLAY)



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::SavedMouseButton> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();

    static void encode(JSC::EncodedValue&, const Test::SavedMouseButton&);
    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::SavedMouseButton>&);
};
template<> struct EncodingTraits<WebCore::MouseButton> {
    typedef WebCore::MouseButton DecodedType;

    static EncodedValue encodeValue(const WebCore::MouseButton& value);
    static bool decodeValue(EncodedValue&, WebCore::MouseButton& value);
};
} // namespace JSC

namespace Test {
class SavedMouseButton : public NondeterministicInput<SavedMouseButton> {
public:
    TEST_EXPORT_MACRO SavedMouseButton(MouseButton button);
    virtual ~SavedMouseButton();

    MouseButton button() const { return m_button; }




#if ENABLE(WEB_REPLAY)
#include "InternalNamespaceImplIncludeDummy.h"
#include "NondeterministicInput.h"
#include "PlatformMouseEvent.h"
#include <platform/ExternalNamespaceImplIncludeDummy.h>
#include <platform/PlatformMouseEvent.h>
#include <replay/NondeterministicInput.h>

namespace Test {
SavedMouseButton::SavedMouseButton(MouseButton button)


void InputTraits<Test::SavedMouseButton>::encode(EncodedValue& encodedValue, const Test::SavedMouseButton& input)
{
    encodedValue.put<Test::MouseButton>(ASCIILiteral("button"), input.button());
}

bool InputTraits<Test::SavedMouseButton>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::SavedMouseButton>& input)
{
    Test::MouseButton button;
    if (!encodedValue.get<Test::MouseButton>(ASCIILiteral("button"), button))
        return false;

    input = std::make_unique<Test::SavedMouseButton>(button);
    return true;
}
EncodedValue EncodingTraits<Test::InputQueue>::encodeValue(const Test::InputQueue& enumValue)
{
    switch (enumValue) {
    case Test::InputQueue::EventLoopInput: return EncodedValue::createString("EventLoopInput");
    case Test::InputQueue::LoaderMemoizedData: return EncodedValue::createString("LoaderMemoizedData");
    case Test::InputQueue::ScriptMemoizedData: return EncodedValue::createString("ScriptMemoizedData");
    default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
    }
}

bool EncodingTraits<Test::InputQueue>::decodeValue(EncodedValue& encodedValue, Test::InputQueue& enumValue)
{
    String enumString = encodedValue.convertTo<String>();
    if (enumString == "EventLoopInput") {
        enumValue = Test::InputQueue::EventLoopInput;
        return true;
    }
    if (enumString == "LoaderMemoizedData") {
        enumValue = Test::InputQueue::LoaderMemoizedData;
        return true;
    }
    if (enumString == "ScriptMemoizedData") {
        enumValue = Test::InputQueue::ScriptMemoizedData;
        return true;
    }
    return false;
}

EncodedValue EncodingTraits<Test::MouseButton>::encodeValue(const Test::MouseButton& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & Test::NoButton) {
        encodedValue.append<String>(ASCIILiteral("NoButton"));
        if (enumValue == Test::NoButton)
            return encodedValue;
    }
    if (enumValue & Test::LeftButton) {
        encodedValue.append<String>(ASCIILiteral("LeftButton"));
        if (enumValue == Test::LeftButton)
            return encodedValue;
    }
    if (enumValue & Test::MiddleButton) {
        encodedValue.append<String>(ASCIILiteral("MiddleButton"));
        if (enumValue == Test::MiddleButton)
            return encodedValue;
    }
    if (enumValue & Test::RightButton) {
        encodedValue.append<String>(ASCIILiteral("RightButton"));
        if (enumValue == Test::RightButton)
            return encodedValue;
    }
    return encodedValue;
}

bool EncodingTraits<Test::MouseButton>::decodeValue(EncodedValue& encodedValue, Test::MouseButton& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))


    for (const String& enumString : enumStrings) {
        if (enumString == "NoButton")
            enumValue = static_cast<Test::MouseButton>(enumValue | Test::NoButton);
        else if (enumString == "LeftButton")
            enumValue = static_cast<Test::MouseButton>(enumValue | Test::LeftButton);
        else if (enumString == "MiddleButton")
            enumValue = static_cast<Test::MouseButton>(enumValue | Test::MiddleButton);
        else if (enumString == "RightButton")
            enumValue = static_cast<Test::MouseButton>(enumValue | Test::RightButton);
    }

    return true;
}

EncodedValue EncodingTraits<Test::PlatformEvent::Type>::encodeValue(const Test::PlatformEvent::Type& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & Test::PlatformEvent::Mouse) {
        encodedValue.append<String>(ASCIILiteral("Mouse"));
        if (enumValue == Test::PlatformEvent::Mouse)
            return encodedValue;
    }
    if (enumValue & Test::PlatformEvent::Key) {
        encodedValue.append<String>(ASCIILiteral("Key"));
        if (enumValue == Test::PlatformEvent::Key)
            return encodedValue;
    }
    if (enumValue & Test::PlatformEvent::Touch) {
        encodedValue.append<String>(ASCIILiteral("Touch"));
        if (enumValue == Test::PlatformEvent::Touch)
            return encodedValue;
    }
    if (enumValue & Test::PlatformEvent::Wheel) {
        encodedValue.append<String>(ASCIILiteral("Wheel"));
        if (enumValue == Test::PlatformEvent::Wheel)
            return encodedValue;
    }
    return encodedValue;
}

bool EncodingTraits<Test::PlatformEvent::Type>::decodeValue(EncodedValue& encodedValue, Test::PlatformEvent::Type& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))


    for (const String& enumString : enumStrings) {
        if (enumString == "Mouse")
            enumValue = static_cast<Test::PlatformEvent::Type>(enumValue | Test::PlatformEvent::Mouse);
        else if (enumString == "Key")
            enumValue = static_cast<Test::PlatformEvent::Type>(enumValue | Test::PlatformEvent::Key);
        else if (enumString == "Touch")
            enumValue = static_cast<Test::PlatformEvent::Type>(enumValue | Test::PlatformEvent::Touch);
        else if (enumString == "Wheel")
            enumValue = static_cast<Test::PlatformEvent::Type>(enumValue | Test::PlatformEvent::Wheel);
    }

    return true;




#if ENABLE(WEB_REPLAY)
#include "InternalNamespaceHeaderIncludeDummy.h"
#include "PlatformEvent.h"
#include <platform/ExternalNamespaceHeaderIncludeDummy.h>
#include <platform/PlatformEvent.h>

namespace Test {
enum MouseButton : unsigned;
}

namespace JSC {
enum class InputQueue;
}


} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::SavedMouseButton> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();

    static void encode(JSC::EncodedValue&, const Test::SavedMouseButton&);
    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::SavedMouseButton>&);
};
template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::InputQueue> {
    typedef Test::InputQueue DecodedType;

    static EncodedValue encodeValue(const Test::InputQueue& value);
    static bool decodeValue(EncodedValue&, Test::InputQueue& value);
};

template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::MouseButton> {
    typedef Test::MouseButton DecodedType;

    static EncodedValue encodeValue(const Test::MouseButton& value);
    static bool decodeValue(EncodedValue&, Test::MouseButton& value);
};

template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::PlatformEvent::Type> {
    typedef Test::PlatformEvent::Type DecodedType;

    static EncodedValue encodeValue(const Test::PlatformEvent::Type& value);
    static bool decodeValue(EncodedValue&, Test::PlatformEvent::Type& value);
};
} // namespace JSC

namespace Test {
class SavedMouseButton : public NondeterministicInput<SavedMouseButton> {
public:
    TEST_EXPORT_MACRO SavedMouseButton(MouseButton button);
    virtual ~SavedMouseButton();

    MouseButton button() const { return m_button; }




#if ENABLE(WEB_REPLAY)
#include "InternalNamespaceImplIncludeDummy.h"
#include "PlatformWheelEvent.h"
#include <platform/ExternalNamespaceImplIncludeDummy.h>
#include <platform/PlatformWheelEvent.h>

namespace Test {
HandleWheelEvent::HandleWheelEvent(std::unique_ptr<PlatformWheelEvent> platformEvent, PlatformWheelPhase phase)
    : EventLoopInput<HandleWheelEvent>()
    , m_platformEvent(WTF::move(platformEvent))
    , m_phase(phase)
{
}


void InputTraits<Test::HandleWheelEvent>::encode(EncodedValue& encodedValue, const Test::HandleWheelEvent& input)
{
    encodedValue.put<WebCore::PlatformWheelEvent>(ASCIILiteral("platformEvent"), input.platformEvent());
    encodedValue.put<Test::PlatformWheelPhase>(ASCIILiteral("phase"), input.phase());
}

bool InputTraits<Test::HandleWheelEvent>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::HandleWheelEvent>& input)

    if (!encodedValue.get<WebCore::PlatformWheelEvent>(ASCIILiteral("platformEvent"), platformEvent))
        return false;

    Test::PlatformWheelPhase phase;
    if (!encodedValue.get<Test::PlatformWheelPhase>(ASCIILiteral("phase"), phase))
        return false;

    input = std::make_unique<Test::HandleWheelEvent>(WTF::move(platformEvent), phase);
    return true;
}
#if ENABLE(DUMMY_FEATURE)
EncodedValue EncodingTraits<Test::PlatformWheelPhase>::encodeValue(const Test::PlatformWheelPhase& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & Test::PlatformWheelEventPhaseNone) {
        encodedValue.append<String>(ASCIILiteral("PlatformWheelEventPhaseNone"));
        if (enumValue == Test::PlatformWheelEventPhaseNone)
            return encodedValue;
    }
    return encodedValue;
}

bool EncodingTraits<Test::PlatformWheelPhase>::decodeValue(EncodedValue& encodedValue, Test::PlatformWheelPhase& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))


    for (const String& enumString : enumStrings) {
        if (enumString == "PlatformWheelEventPhaseNone")
            enumValue = static_cast<Test::PlatformWheelPhase>(enumValue | Test::PlatformWheelEventPhaseNone);
    }

    return true;



#include "InternalNamespaceHeaderIncludeDummy.h"
#include <platform/ExternalNamespaceHeaderIncludeDummy.h>

namespace Test {
enum PlatformWheelPhase : uint64_t;
}

namespace WebCore {
class PlatformWheelEvent;
enum PlatformWheelEventPhase : uint64_t;
}



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::HandleWheelEvent> {
    static InputQueue queue() { return InputQueue::EventLoopInput; }
    static const String& type();


    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::HandleWheelEvent>&);
};
#if ENABLE(DUMMY_FEATURE)
template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::PlatformWheelPhase> {
    typedef Test::PlatformWheelPhase DecodedType;

    static EncodedValue encodeValue(const Test::PlatformWheelPhase& value);
    static bool decodeValue(EncodedValue&, Test::PlatformWheelPhase& value);
};
#endif // ENABLE(DUMMY_FEATURE)
} // namespace JSC

namespace Test {
class HandleWheelEvent : public EventLoopInput<HandleWheelEvent> {
public:
    TEST_EXPORT_MACRO HandleWheelEvent(std::unique_ptr<PlatformWheelEvent> platformEvent, PlatformWheelPhase phase);
    virtual ~HandleWheelEvent();

    // EventLoopInput API
    virtual void dispatch(ReplayController&) override final;
    const PlatformWheelEvent& platformEvent() const { return *m_platformEvent; }
    PlatformWheelPhase phase() const { return m_phase; }
private:
    std::unique_ptr<PlatformWheelEvent> m_platformEvent;
    PlatformWheelPhase m_phase;
};
} // namespace Test




{
    encodedValue.put<PlatformEvent1::Type>(ASCIILiteral("eventType1"), input.eventType1());
    encodedValue.put<PlatformEvent2::Type>(ASCIILiteral("eventType2"), input.eventType2());
    encodedValue.put<Test::FormData1::Type>(ASCIILiteral("formType1"), input.formType1());
    encodedValue.put<Test::FormData2::Type>(ASCIILiteral("formType2"), input.formType2());
}

bool InputTraits<Test::FormCombo>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::FormCombo>& input)

    if (!encodedValue.get<PlatformEvent2::Type>(ASCIILiteral("eventType2"), eventType2))
        return false;

    Test::FormData1::Type formType1;
    if (!encodedValue.get<Test::FormData1::Type>(ASCIILiteral("formType1"), formType1))
        return false;

    Test::FormData2::Type formType2;
    if (!encodedValue.get<Test::FormData2::Type>(ASCIILiteral("formType2"), formType2))
        return false;

    input = std::make_unique<Test::FormCombo>(eventType1, eventType2, formType1, formType2);
    return true;
}
EncodedValue EncodingTraits<Test::FormData1::Type>::encodeValue(const Test::FormData1::Type& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & Test::FormData1::Text) {
        encodedValue.append<String>(ASCIILiteral("Text"));
        if (enumValue == Test::FormData1::Text)
            return encodedValue;
    }
    if (enumValue & Test::FormData1::Blob) {
        encodedValue.append<String>(ASCIILiteral("Blob"));
        if (enumValue == Test::FormData1::Blob)
            return encodedValue;
    }
    return encodedValue;
}

bool EncodingTraits<Test::FormData1::Type>::decodeValue(EncodedValue& encodedValue, Test::FormData1::Type& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))


    for (const String& enumString : enumStrings) {
        if (enumString == "Text")
            enumValue = static_cast<Test::FormData1::Type>(enumValue | Test::FormData1::Text);
        else if (enumString == "Blob")
            enumValue = static_cast<Test::FormData1::Type>(enumValue | Test::FormData1::Blob);
    }

    return true;
}

EncodedValue EncodingTraits<Test::FormData2::Type>::encodeValue(const Test::FormData2::Type& enumValue)
{
    switch (enumValue) {
    case Test::FormData2::Type::Text: return EncodedValue::createString("Text");
    case Test::FormData2::Type::Blob: return EncodedValue::createString("Blob");
    default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
    }
}

bool EncodingTraits<Test::FormData2::Type>::decodeValue(EncodedValue& encodedValue, Test::FormData2::Type& enumValue)
{
    String enumString = encodedValue.convertTo<String>();
    if (enumString == "Text") {
        enumValue = Test::FormData2::Type::Text;
        return true;
    }
    if (enumString == "Blob") {
        enumValue = Test::FormData2::Type::Blob;
        return true;
    }
    return false;
}

EncodedValue EncodingTraits<PlatformEvent1::Type>::encodeValue(const PlatformEvent1::Type& enumValue)
{
    EncodedValue encodedValue = EncodedValue::createArray();
    if (enumValue & PlatformEvent1::Mouse) {
        encodedValue.append<String>(ASCIILiteral("Mouse"));
        if (enumValue == PlatformEvent1::Mouse)
            return encodedValue;
    }
    if (enumValue & PlatformEvent1::Keyboard) {
        encodedValue.append<String>(ASCIILiteral("Keyboard"));
        if (enumValue == PlatformEvent1::Keyboard)
            return encodedValue;
    }
    return encodedValue;
}

bool EncodingTraits<PlatformEvent1::Type>::decodeValue(EncodedValue& encodedValue, PlatformEvent1::Type& enumValue)
{
    Vector<String> enumStrings;
    if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
        return false;

    for (const String& enumString : enumStrings) {
        if (enumString == "Mouse")
            enumValue = static_cast<PlatformEvent1::Type>(enumValue | PlatformEvent1::Mouse);
        else if (enumString == "Keyboard")
            enumValue = static_cast<PlatformEvent1::Type>(enumValue | PlatformEvent1::Keyboard);
    }

    return true;
}

EncodedValue EncodingTraits<PlatformEvent2::Type>::encodeValue(const PlatformEvent2::Type& enumValue)
{
    switch (enumValue) {
    case PlatformEvent2::Type::Mouse: return EncodedValue::createString("Mouse");
    case PlatformEvent2::Type::Keyboard: return EncodedValue::createString("Keyboard");
    default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
    }
}

bool EncodingTraits<PlatformEvent2::Type>::decodeValue(EncodedValue& encodedValue, PlatformEvent2::Type& enumValue)
{
    String enumString = encodedValue.convertTo<String>();
    if (enumString == "Mouse") {
        enumValue = PlatformEvent2::Type::Mouse;
        return true;
    }
    if (enumString == "Keyboard") {
        enumValue = PlatformEvent2::Type::Keyboard;
        return true;
    }
    return false;



#define generate_enums_with_same_base_name_json_TestReplayInputs_h

#if ENABLE(WEB_REPLAY)
#include "FormData1.h"
#include "FormData2.h"
#include "InternalNamespaceHeaderIncludeDummy.h"
#include <platform/ExternalNamespaceHeaderIncludeDummy.h>
#include <replay/FormData1.h>
#include <replay/FormData2.h>
#include <replay/PlatformEvent.h>



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::FormCombo> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();

    static void encode(JSC::EncodedValue&, const Test::FormCombo&);
    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::FormCombo>&);
};
template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::FormData1::Type> {
    typedef Test::FormData1::Type DecodedType;

    static EncodedValue encodeValue(const Test::FormData1::Type& value);
    static bool decodeValue(EncodedValue&, Test::FormData1::Type& value);
};

template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::FormData2::Type> {
    typedef Test::FormData2::Type DecodedType;

    static EncodedValue encodeValue(const Test::FormData2::Type& value);
    static bool decodeValue(EncodedValue&, Test::FormData2::Type& value);
};

template<> struct EncodingTraits<PlatformEvent1::Type> {
    typedef PlatformEvent1::Type DecodedType;

    static EncodedValue encodeValue(const PlatformEvent1::Type& value);
    static bool decodeValue(EncodedValue&, PlatformEvent1::Type& value);
};

template<> struct EncodingTraits<PlatformEvent2::Type> {
    typedef PlatformEvent2::Type DecodedType;

    static EncodedValue encodeValue(const PlatformEvent2::Type& value);
    static bool decodeValue(EncodedValue&, PlatformEvent2::Type& value);
};
} // namespace JSC

namespace Test {
class FormCombo : public NondeterministicInput<FormCombo> {
public:
    TEST_EXPORT_MACRO FormCombo(PlatformEvent1::Type eventType1, PlatformEvent2::Type eventType2, FormData1::Type formType1, FormData2::Type formType2);
    virtual ~FormCombo();

    PlatformEvent1::Type eventType1() const { return m_eventType1; }




namespace JSC {
#if ENABLE(DUMMY_FEATURE)
template<> struct TEST_EXPORT_MACRO InputTraits<Test::GetCurrentTime> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


};
#endif // ENABLE(DUMMY_FEATURE)

template<> struct TEST_EXPORT_MACRO InputTraits<Test::SetRandomSeed> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


#if ENABLE(DUMMY_FEATURE)
class GetCurrentTime : public NondeterministicInput<GetCurrentTime> {
public:
    TEST_EXPORT_MACRO GetCurrentTime(double currentTime);
    virtual ~GetCurrentTime();

    double currentTime() const { return m_currentTime; }


class SetRandomSeed : public NondeterministicInput<SetRandomSeed> {
public:
    TEST_EXPORT_MACRO SetRandomSeed(uint64_t randomSeed);
    virtual ~SetRandomSeed();

    uint64_t randomSeed() const { return m_randomSeed; }



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::ArrayOfThings> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::ArrayOfThings>&);
};

template<> struct TEST_EXPORT_MACRO InputTraits<Test::SavedHistory> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


namespace Test {
class ArrayOfThings : public NondeterministicInput<ArrayOfThings> {
public:
    TEST_EXPORT_MACRO ArrayOfThings(Vector<double>& doubles, Vector<JSThing>& jsthings, Vector<WebThing>& webthings);
    virtual ~ArrayOfThings();

    const Vector<double>& doubles() const { return m_doubles; }


class SavedHistory : public NondeterministicInput<SavedHistory> {
public:
    TEST_EXPORT_MACRO SavedHistory(Vector<RefPtr<HistoryItem>>& entries);
    virtual ~SavedHistory();

    const Vector<RefPtr<HistoryItem>>& entries() const { return m_entries; }



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::ScalarInput1> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::ScalarInput1>&);
};

template<> struct TEST_EXPORT_MACRO InputTraits<Test::ScalarInput2> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


namespace Test {
class ScalarInput1 : public NondeterministicInput<ScalarInput1> {
public:
    TEST_EXPORT_MACRO ScalarInput1(ScalarType data);
    virtual ~ScalarInput1();

    ScalarType data() const { return m_data; }


class ScalarInput2 : public NondeterministicInput<ScalarInput2> {
public:
    TEST_EXPORT_MACRO ScalarInput2(ScalarType data);
    virtual ~ScalarInput2();

    ScalarType data() const { return m_data; }



} // namespace Test

namespace JSC {
template<> struct TEST_EXPORT_MACRO InputTraits<Test::ScalarInput> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


    static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::ScalarInput>&);
};

template<> struct TEST_EXPORT_MACRO InputTraits<Test::MapInput> {
    static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
    static const String& type();


namespace Test {
class ScalarInput : public NondeterministicInput<ScalarInput> {
public:
    TEST_EXPORT_MACRO ScalarInput(ScalarType data);
    virtual ~ScalarInput();

    ScalarType data() const { return m_data; }


class MapInput : public NondeterministicInput<MapInput> {
public:
    TEST_EXPORT_MACRO MapInput(std::unique_ptr<MapType> data);
    virtual ~MapInput();

    const MapType& data() const { return *m_data; }



{
    "types": {
        "Test": [
            {
                "name": "InputQueue", "mode": "SCALAR",
                "flags": ["ENUM_CLASS"],
                "values": ["EventLoopInput", "LoaderMemoizedData", "ScriptMemoizedData"],
                "header": "replay/NondeterministicInput.h"
            },
        ],
        "WebCore": [
            {
                "name": "MouseButton", "mode": "SCALAR", "storage": "unsigned",
                "flags": ["ENUM"],

Lines 7-15 a/Source/JavaScriptCore/replay/scripts/tests/generate-enum-with-guard.json_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/generate-enum-with-guard.json -3 / +6 lines
7	{	7	{
8	"name": "PlatformWheelEvent", "mode": "OWNED",	8	"name": "PlatformWheelEvent", "mode": "OWNED",
9	"header": "platform/PlatformWheelEvent.h"	9	"header": "platform/PlatformWheelEvent.h"
10	},	10	}
		11	],
		12	"Test": [
11	{	13	{
12	"name": "PlatformWheelEventPhase", "mode": "SCALAR", "storage": "uint64_t",	14	"name": "PlatformWheelPhase", "mode": "SCALAR", "storage": "uint64_t",
13	"flags": ["ENUM"],	15	"flags": ["ENUM"],
14	"guard": "ENABLE(DUMMY_FEATURE)",	16	"guard": "ENABLE(DUMMY_FEATURE)",
15	"values": ["PlatformWheelEventPhaseNone"],	17	"values": ["PlatformWheelEventPhaseNone"],
Lines 24-30 a/Source/JavaScriptCore/replay/scripts/tests/generate-enum-with-guard.json_sec2
24	"description": "",	26	"description": "",
25	"queue": "EVENT_LOOP",	27	"queue": "EVENT_LOOP",
26	"members": [	28	"members": [
27	{ "name": "platformEvent", "type": "PlatformWheelEvent" }	29	{ "name": "platformEvent", "type": "PlatformWheelEvent" },
		30	{ "name": "phase", "type": "PlatformWheelPhase" }
28	]	31	]
29	}	32	}
30	]	33	]

Lines 16-22 a/Source/JavaScriptCore/replay/scripts/tests/generate-enums-with-same-base-name.json_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/generate-enums-with-same-base-name.json -1 / +1 lines
16	"header": "replay/PlatformEvent.h"	16	"header": "replay/PlatformEvent.h"
17	}	17	}
18	],	18	],
19	"WebCore": [	19	"Test": [
20	{	20	{
21	"name": "Type", "mode": "SCALAR", "storage": "uint64_t",	21	"name": "Type", "mode": "SCALAR", "storage": "uint64_t",
22	"enclosing_class": "FormData1",	22	"enclosing_class": "FormData1",

Return to Bug 136311

Lines 105-123 ${forEachMacro} a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputsTemplates.py_sec1
- a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputsTemplates.py -12 / +12 lines
105	};""")	105	};""")
106		106
107	EnumTraitDeclaration = (	107	EnumTraitDeclaration = (
108	"""template<> struct EncodingTraits<${enumName}> {	108	"""template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
109	typedef ${enumName} DecodedType;	109	typedef ${enumType} DecodedType;
110		110
111	static EncodedValue encodeValue(const ${enumName}& value);	111	static EncodedValue encodeValue(const ${enumType}& value);
112	static bool decodeValue(EncodedValue&, ${enumName}& value);	112	static bool decodeValue(EncodedValue&, ${enumType}& value);
113	};""")	113	};""")
114		114
115	EnumClassTraitDeclaration = (	115	EnumClassTraitDeclaration = (
116	"""template<> struct EncodingTraits<${enumName}> {	116	"""template<> ${structOrClass} EncodingTraits<${encodingTypeArgument}> {
117	typedef ${enumName} DecodedType;	117	typedef ${enumType} DecodedType;
118		118
119	static EncodedValue encodeValue(const ${enumName}& value);	119	static EncodedValue encodeValue(const ${enumType}& value);
120	static bool decodeValue(EncodedValue&, ${enumName}& value);	120	static bool decodeValue(EncodedValue&, ${enumType}& value);
121	};""")	121	};""")
122		122
123	InputClassDeclaration = (	123	InputClassDeclaration = (
Lines 171-177 ${decodeSteps} a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputsTemplates.py_sec2
171	}""")	171	}""")
172		172
173	EnumClassTraitImplementation = (	173	EnumClassTraitImplementation = (
174	"""EncodedValue EncodingTraits<${enumName}>::encodeValue(const ${enumName}& enumValue)	174	"""EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
175	{	175	{
176	switch (enumValue) {	176	switch (enumValue) {
177	${encodeCases}	177	${encodeCases}
Lines 179-185 ${encodeCases} a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputsTemplates.py_sec3
179	}	179	}
180	}	180	}
181		181
182	bool EncodingTraits<${enumName}>::decodeValue(EncodedValue& encodedValue, ${enumName}& enumValue)	182	bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
183	{	183	{
184	String enumString = encodedValue.convertTo<String>();	184	String enumString = encodedValue.convertTo<String>();
185	${decodeCases}	185	${decodeCases}
Lines 196-209 ${decodeCases} a/Source/JavaScriptCore/replay/scripts/CodeGeneratorReplayInputsTemplates.py_sec4
196	}""")	196	}""")
197		197
198	EnumTraitImplementation = (	198	EnumTraitImplementation = (
199	"""EncodedValue EncodingTraits<${enumName}>::encodeValue(const ${enumName}& enumValue)	199	"""EncodedValue EncodingTraits<${encodingTypeArgument}>::encodeValue(const ${enumType}& enumValue)
200	{	200	{
201	EncodedValue encodedValue = EncodedValue::createArray();	201	EncodedValue encodedValue = EncodedValue::createArray();
202	${encodeCases}	202	${encodeCases}
203	return encodedValue;	203	return encodedValue;
204	}	204	}
205		205
206	bool EncodingTraits<${enumName}>::decodeValue(EncodedValue& encodedValue, ${enumName}& enumValue)	206	bool EncodingTraits<${encodingTypeArgument}>::decodeValue(EncodedValue& encodedValue, ${enumType}& enumValue)
207	{	207	{
208	Vector<String> enumStrings;	208	Vector<String> enumStrings;
209	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))	209	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +42 lines
		1	2015-01-14 Brian J. Burg <burg@cs.washington.edu>
		2
		3	Web Replay: only generate EncodingTraits for enums defined in the target framework
		4	https://bugs.webkit.org/show_bug.cgi?id=136311
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Don't generate EncodingTraits for enums unless they belong to the target framework.
		9	Otherwise, enums used in multiple frameworks' inputs cannot be unambiguously encoded/decoded
		10	because they will have more than one generated implementation.
		11
		12	For now, some type definitions will be duplicated between JSON specification files.
		13	This will be fixed in a follow-up bug that teaches the generator about supplemental specifications.
		14
		15	Use Type.encoding_type_argument in more places, and add the export macro for WebCore.
		16
		17	Adjust some tests so that enum coverage is preserved by moving the enum types into "Test"
		18	(the target framework for tests).
		19
		20	* replay/JSInputs.json: Copy the InputQueue enum to here. It will be removed from WebInputs.json
		21	in a future patch when supplemental input specifications can be read by the generator.
		22	* replay/scripts/CodeGeneratorReplayInputs.py:
		23	(Generator.generate_header): Selectively generate traits.
		24	(Generator.generate_implementation):
		25	(Generator.generate_enum_trait_implementation): add WEBCORE_EXPORT macro to enum encoding traits.
		26	* replay/scripts/CodeGeneratorReplayInputsTemplates.py:
		27	* replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.cpp:
		28	* replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.h:
		29	* replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp:
		30	* replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.h:
		31	* replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.cpp:
		32	* replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h:
		33	* replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp:
		34	* replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.h:
		35	* replay/scripts/tests/expected/generate-input-with-guard.json-TestReplayInputs.h:
		36	* replay/scripts/tests/expected/generate-input-with-vector-members.json-TestReplayInputs.h:
		37	* replay/scripts/tests/expected/generate-inputs-with-flags.json-TestReplayInputs.h:
		38	* replay/scripts/tests/expected/generate-memoized-type-modes.json-TestReplayInputs.h:
		39	* replay/scripts/tests/generate-enum-encoding-helpers.json:
		40	* replay/scripts/tests/generate-enum-with-guard.json: Include enums that are and are not generated.
		41	* replay/scripts/tests/generate-enums-with-same-base-name.json:
		42
1	2015-01-14 Matthew Mirman <mmirman@apple.com>	43	2015-01-14 Matthew Mirman <mmirman@apple.com>
2		44
3	Removed accidental commit of "invalid_array.js"	45	Removed accidental commit of "invalid_array.js"

Lines 68-147 bool InputTraits<Test::SavedMouseButton>::decode(EncodedValue& encodedValue, std a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.cpp_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.cpp -73 lines
68	input = std::make_unique<Test::SavedMouseButton>(button);	68	input = std::make_unique<Test::SavedMouseButton>(button);
69	return true;	69	return true;
70	}	70	}
71	EncodedValue EncodingTraits<WebCore::MouseButton>::encodeValue(const WebCore::MouseButton& enumValue)
72	{
73	EncodedValue encodedValue = EncodedValue::createArray();
74	if (enumValue & WebCore::NoButton) {
75	encodedValue.append<String>(ASCIILiteral("NoButton"));
76	if (enumValue == WebCore::NoButton)
77	return encodedValue;
78	}
79	if (enumValue & WebCore::LeftButton) {
80	encodedValue.append<String>(ASCIILiteral("LeftButton"));
81	if (enumValue == WebCore::LeftButton)
82	return encodedValue;
83	}
84	if (enumValue & WebCore::MiddleButton) {
85	encodedValue.append<String>(ASCIILiteral("MiddleButton"));
86	if (enumValue == WebCore::MiddleButton)
87	return encodedValue;
88	}
89	if (enumValue & WebCore::RightButton) {
90	encodedValue.append<String>(ASCIILiteral("RightButton"));
91	if (enumValue == WebCore::RightButton)
92	return encodedValue;
93	}
94	#if ENABLE(SIDE_BUTTONS)
95	if (enumValue & WebCore::LeftSideButton) {
96	encodedValue.append<String>(ASCIILiteral("LeftSideButton"));
97	if (enumValue == WebCore::LeftSideButton)
98	return encodedValue;
99	}
100	if (enumValue & WebCore::RightSideButton) {
101	encodedValue.append<String>(ASCIILiteral("RightSideButton"));
102	if (enumValue == WebCore::RightSideButton)
103	return encodedValue;
104	}
105	#endif // ENABLE(SIDE_BUTTONS)
106	#if PLATFORM(WINDOWS)
107	if (enumValue & WebCore::WindowsButton) {
108	encodedValue.append<String>(ASCIILiteral("WindowsButton"));
109	if (enumValue == WebCore::WindowsButton)
110	return encodedValue;
111	}
112	#endif // PLATFORM(WINDOWS)
113	return encodedValue;
114	}
115
116	bool EncodingTraits<WebCore::MouseButton>::decodeValue(EncodedValue& encodedValue, WebCore::MouseButton& enumValue)
117	{
118	Vector<String> enumStrings;
119	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
120	return false;
121
122	for (const String& enumString : enumStrings) {
123	if (enumString == "NoButton")
124	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::NoButton);
125	else if (enumString == "LeftButton")
126	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::LeftButton);
127	else if (enumString == "MiddleButton")
128	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::MiddleButton);
129	else if (enumString == "RightButton")
130	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::RightButton);
131	#if ENABLE(SIDE_BUTTONS)
132	if (enumString == "LeftSideButton")
133	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::LeftSideButton);
134	else if (enumString == "RightSideButton")
135	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::RightSideButton);
136	#endif // ENABLE(SIDE_BUTTONS)
137	#if PLATFORM(WINDOWS)
138	if (enumString == "WindowsButton")
139	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::WindowsButton);
140	#endif // PLATFORM(WINDOWS)
141	}
142		71
143	return true;
144	}
145	} // namespace JSC	72	} // namespace JSC
146		73
147	#endif // ENABLE(WEB_REPLAY)	74	#endif // ENABLE(WEB_REPLAY)

Lines 44-68 class SavedMouseButton; a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.h_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers-with-guarded-values.json-TestReplayInputs.h -7 / +2 lines
44	} // namespace Test	44	} // namespace Test
45		45
46	namespace JSC {	46	namespace JSC {
47	template<> struct InputTraits<Test::SavedMouseButton> {	47	template<> struct TEST_EXPORT_MACRO InputTraits<Test::SavedMouseButton> {
48	static InputQueue queue() { return InputQueue::ScriptMemoizedData; }	48	static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
49	static const String& type();	49	static const String& type();
50		50
51	static void encode(JSC::EncodedValue&, const Test::SavedMouseButton&);	51	static void encode(JSC::EncodedValue&, const Test::SavedMouseButton&);
52	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::SavedMouseButton>&);	52	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::SavedMouseButton>&);
53	};	53	};
54	template<> struct EncodingTraits<WebCore::MouseButton> {
55	typedef WebCore::MouseButton DecodedType;
56		54
57	static EncodedValue encodeValue(const WebCore::MouseButton& value);
58	static bool decodeValue(EncodedValue&, WebCore::MouseButton& value);
59	};
60	} // namespace JSC	55	} // namespace JSC
61		56
62	namespace Test {	57	namespace Test {
63	class SavedMouseButton : public NondeterministicInput<SavedMouseButton> {	58	class SavedMouseButton : public NondeterministicInput<SavedMouseButton> {
64	public:	59	public:
65	SavedMouseButton(MouseButton button);	60	TEST_EXPORT_MACRO SavedMouseButton(MouseButton button);
66	virtual ~SavedMouseButton();	61	virtual ~SavedMouseButton();
67		62
68	MouseButton button() const { return m_button; }	63	MouseButton button() const { return m_button; }

Lines 32-40 a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp -41 / +41 lines
32		32
33	#if ENABLE(WEB_REPLAY)	33	#if ENABLE(WEB_REPLAY)
34	#include "InternalNamespaceImplIncludeDummy.h"	34	#include "InternalNamespaceImplIncludeDummy.h"
		35	#include "NondeterministicInput.h"
		36	#include "PlatformMouseEvent.h"
35	#include <platform/ExternalNamespaceImplIncludeDummy.h>	37	#include <platform/ExternalNamespaceImplIncludeDummy.h>
36	#include <platform/PlatformMouseEvent.h>
37	#include <replay/NondeterministicInput.h>
38		38
39	namespace Test {	39	namespace Test {
40	SavedMouseButton::SavedMouseButton(MouseButton button)	40	SavedMouseButton::SavedMouseButton(MouseButton button)
Lines 57-129 const String& InputTraits<Test::SavedMouseButton>::type() a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp_sec2
57		57
58	void InputTraits<Test::SavedMouseButton>::encode(EncodedValue& encodedValue, const Test::SavedMouseButton& input)	58	void InputTraits<Test::SavedMouseButton>::encode(EncodedValue& encodedValue, const Test::SavedMouseButton& input)
59	{	59	{
60	encodedValue.put<WebCore::MouseButton>(ASCIILiteral("button"), input.button());	60	encodedValue.put<Test::MouseButton>(ASCIILiteral("button"), input.button());
61	}	61	}
62		62
63	bool InputTraits<Test::SavedMouseButton>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::SavedMouseButton>& input)	63	bool InputTraits<Test::SavedMouseButton>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::SavedMouseButton>& input)
64	{	64	{
65	WebCore::MouseButton button;	65	Test::MouseButton button;
66	if (!encodedValue.get<WebCore::MouseButton>(ASCIILiteral("button"), button))	66	if (!encodedValue.get<Test::MouseButton>(ASCIILiteral("button"), button))
67	return false;	67	return false;
68		68
69	input = std::make_unique<Test::SavedMouseButton>(button);	69	input = std::make_unique<Test::SavedMouseButton>(button);
70	return true;	70	return true;
71	}	71	}
72	EncodedValue EncodingTraits<InputQueue>::encodeValue(const InputQueue& enumValue)	72	EncodedValue EncodingTraits<Test::InputQueue>::encodeValue(const Test::InputQueue& enumValue)
73	{	73	{
74	switch (enumValue) {	74	switch (enumValue) {
75	case InputQueue::EventLoopInput: return EncodedValue::createString("EventLoopInput");	75	case Test::InputQueue::EventLoopInput: return EncodedValue::createString("EventLoopInput");
76	case InputQueue::LoaderMemoizedData: return EncodedValue::createString("LoaderMemoizedData");	76	case Test::InputQueue::LoaderMemoizedData: return EncodedValue::createString("LoaderMemoizedData");
77	case InputQueue::ScriptMemoizedData: return EncodedValue::createString("ScriptMemoizedData");	77	case Test::InputQueue::ScriptMemoizedData: return EncodedValue::createString("ScriptMemoizedData");
78	default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");	78	default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
79	}	79	}
80	}	80	}
81		81
82	bool EncodingTraits<InputQueue>::decodeValue(EncodedValue& encodedValue, InputQueue& enumValue)	82	bool EncodingTraits<Test::InputQueue>::decodeValue(EncodedValue& encodedValue, Test::InputQueue& enumValue)
83	{	83	{
84	String enumString = encodedValue.convertTo<String>();	84	String enumString = encodedValue.convertTo<String>();
85	if (enumString == "EventLoopInput") {	85	if (enumString == "EventLoopInput") {
86	enumValue = InputQueue::EventLoopInput;	86	enumValue = Test::InputQueue::EventLoopInput;
87	return true;	87	return true;
88	}	88	}
89	if (enumString == "LoaderMemoizedData") {	89	if (enumString == "LoaderMemoizedData") {
90	enumValue = InputQueue::LoaderMemoizedData;	90	enumValue = Test::InputQueue::LoaderMemoizedData;
91	return true;	91	return true;
92	}	92	}
93	if (enumString == "ScriptMemoizedData") {	93	if (enumString == "ScriptMemoizedData") {
94	enumValue = InputQueue::ScriptMemoizedData;	94	enumValue = Test::InputQueue::ScriptMemoizedData;
95	return true;	95	return true;
96	}	96	}
97	return false;	97	return false;
98	}	98	}
99		99
100	EncodedValue EncodingTraits<WebCore::MouseButton>::encodeValue(const WebCore::MouseButton& enumValue)	100	EncodedValue EncodingTraits<Test::MouseButton>::encodeValue(const Test::MouseButton& enumValue)
101	{	101	{
102	EncodedValue encodedValue = EncodedValue::createArray();	102	EncodedValue encodedValue = EncodedValue::createArray();
103	if (enumValue & WebCore::NoButton) {	103	if (enumValue & Test::NoButton) {
104	encodedValue.append<String>(ASCIILiteral("NoButton"));	104	encodedValue.append<String>(ASCIILiteral("NoButton"));
105	if (enumValue == WebCore::NoButton)	105	if (enumValue == Test::NoButton)
106	return encodedValue;	106	return encodedValue;
107	}	107	}
108	if (enumValue & WebCore::LeftButton) {	108	if (enumValue & Test::LeftButton) {
109	encodedValue.append<String>(ASCIILiteral("LeftButton"));	109	encodedValue.append<String>(ASCIILiteral("LeftButton"));
110	if (enumValue == WebCore::LeftButton)	110	if (enumValue == Test::LeftButton)
111	return encodedValue;	111	return encodedValue;
112	}	112	}
113	if (enumValue & WebCore::MiddleButton) {	113	if (enumValue & Test::MiddleButton) {
114	encodedValue.append<String>(ASCIILiteral("MiddleButton"));	114	encodedValue.append<String>(ASCIILiteral("MiddleButton"));
115	if (enumValue == WebCore::MiddleButton)	115	if (enumValue == Test::MiddleButton)
116	return encodedValue;	116	return encodedValue;
117	}	117	}
118	if (enumValue & WebCore::RightButton) {	118	if (enumValue & Test::RightButton) {
119	encodedValue.append<String>(ASCIILiteral("RightButton"));	119	encodedValue.append<String>(ASCIILiteral("RightButton"));
120	if (enumValue == WebCore::RightButton)	120	if (enumValue == Test::RightButton)
121	return encodedValue;	121	return encodedValue;
122	}	122	}
123	return encodedValue;	123	return encodedValue;
124	}	124	}
125		125
126	bool EncodingTraits<WebCore::MouseButton>::decodeValue(EncodedValue& encodedValue, WebCore::MouseButton& enumValue)	126	bool EncodingTraits<Test::MouseButton>::decodeValue(EncodedValue& encodedValue, Test::MouseButton& enumValue)
127	{	127	{
128	Vector<String> enumStrings;	128	Vector<String> enumStrings;
129	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))	129	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
Lines 131-175 bool EncodingTraits<WebCore::MouseButton>::decodeValue(EncodedValue& encodedValu a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp_sec3
131		131
132	for (const String& enumString : enumStrings) {	132	for (const String& enumString : enumStrings) {
133	if (enumString == "NoButton")	133	if (enumString == "NoButton")
134	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::NoButton);	134	enumValue = static_cast<Test::MouseButton>(enumValue \| Test::NoButton);
135	else if (enumString == "LeftButton")	135	else if (enumString == "LeftButton")
136	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::LeftButton);	136	enumValue = static_cast<Test::MouseButton>(enumValue \| Test::LeftButton);
137	else if (enumString == "MiddleButton")	137	else if (enumString == "MiddleButton")
138	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::MiddleButton);	138	enumValue = static_cast<Test::MouseButton>(enumValue \| Test::MiddleButton);
139	else if (enumString == "RightButton")	139	else if (enumString == "RightButton")
140	enumValue = static_cast<WebCore::MouseButton>(enumValue \| WebCore::RightButton);	140	enumValue = static_cast<Test::MouseButton>(enumValue \| Test::RightButton);
141	}	141	}
142		142
143	return true;	143	return true;
144	}	144	}
145		145
146	EncodedValue EncodingTraits<WebCore::PlatformEvent::Type>::encodeValue(const WebCore::PlatformEvent::Type& enumValue)	146	EncodedValue EncodingTraits<Test::PlatformEvent::Type>::encodeValue(const Test::PlatformEvent::Type& enumValue)
147	{	147	{
148	EncodedValue encodedValue = EncodedValue::createArray();	148	EncodedValue encodedValue = EncodedValue::createArray();
149	if (enumValue & WebCore::PlatformEvent::Mouse) {	149	if (enumValue & Test::PlatformEvent::Mouse) {
150	encodedValue.append<String>(ASCIILiteral("Mouse"));	150	encodedValue.append<String>(ASCIILiteral("Mouse"));
151	if (enumValue == WebCore::PlatformEvent::Mouse)	151	if (enumValue == Test::PlatformEvent::Mouse)
152	return encodedValue;	152	return encodedValue;
153	}	153	}
154	if (enumValue & WebCore::PlatformEvent::Key) {	154	if (enumValue & Test::PlatformEvent::Key) {
155	encodedValue.append<String>(ASCIILiteral("Key"));	155	encodedValue.append<String>(ASCIILiteral("Key"));
156	if (enumValue == WebCore::PlatformEvent::Key)	156	if (enumValue == Test::PlatformEvent::Key)
157	return encodedValue;	157	return encodedValue;
158	}	158	}
159	if (enumValue & WebCore::PlatformEvent::Touch) {	159	if (enumValue & Test::PlatformEvent::Touch) {
160	encodedValue.append<String>(ASCIILiteral("Touch"));	160	encodedValue.append<String>(ASCIILiteral("Touch"));
161	if (enumValue == WebCore::PlatformEvent::Touch)	161	if (enumValue == Test::PlatformEvent::Touch)
162	return encodedValue;	162	return encodedValue;
163	}	163	}
164	if (enumValue & WebCore::PlatformEvent::Wheel) {	164	if (enumValue & Test::PlatformEvent::Wheel) {
165	encodedValue.append<String>(ASCIILiteral("Wheel"));	165	encodedValue.append<String>(ASCIILiteral("Wheel"));
166	if (enumValue == WebCore::PlatformEvent::Wheel)	166	if (enumValue == Test::PlatformEvent::Wheel)
167	return encodedValue;	167	return encodedValue;
168	}	168	}
169	return encodedValue;	169	return encodedValue;
170	}	170	}
171		171
172	bool EncodingTraits<WebCore::PlatformEvent::Type>::decodeValue(EncodedValue& encodedValue, WebCore::PlatformEvent::Type& enumValue)	172	bool EncodingTraits<Test::PlatformEvent::Type>::decodeValue(EncodedValue& encodedValue, Test::PlatformEvent::Type& enumValue)
173	{	173	{
174	Vector<String> enumStrings;	174	Vector<String> enumStrings;
175	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))	175	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
Lines 177-189 bool EncodingTraits<WebCore::PlatformEvent::Type>::decodeValue(EncodedValue& enc a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-encoding-helpers.json-TestReplayInputs.cpp_sec4
177		177
178	for (const String& enumString : enumStrings) {	178	for (const String& enumString : enumStrings) {
179	if (enumString == "Mouse")	179	if (enumString == "Mouse")
180	enumValue = static_cast<WebCore::PlatformEvent::Type>(enumValue \| WebCore::PlatformEvent::Mouse);	180	enumValue = static_cast<Test::PlatformEvent::Type>(enumValue \| Test::PlatformEvent::Mouse);
181	else if (enumString == "Key")	181	else if (enumString == "Key")
182	enumValue = static_cast<WebCore::PlatformEvent::Type>(enumValue \| WebCore::PlatformEvent::Key);	182	enumValue = static_cast<Test::PlatformEvent::Type>(enumValue \| Test::PlatformEvent::Key);
183	else if (enumString == "Touch")	183	else if (enumString == "Touch")
184	enumValue = static_cast<WebCore::PlatformEvent::Type>(enumValue \| WebCore::PlatformEvent::Touch);	184	enumValue = static_cast<Test::PlatformEvent::Type>(enumValue \| Test::PlatformEvent::Touch);
185	else if (enumString == "Wheel")	185	else if (enumString == "Wheel")
186	enumValue = static_cast<WebCore::PlatformEvent::Type>(enumValue \| WebCore::PlatformEvent::Wheel);	186	enumValue = static_cast<Test::PlatformEvent::Type>(enumValue \| Test::PlatformEvent::Wheel);
187	}	187	}
188		188
189	return true;	189	return true;

Lines 34-42 a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h -7 / +12 lines
34	#include "InternalNamespaceHeaderIncludeDummy.h"	34	#include "InternalNamespaceHeaderIncludeDummy.h"
35	#include <platform/ExternalNamespaceHeaderIncludeDummy.h>	35	#include <platform/ExternalNamespaceHeaderIncludeDummy.h>
36		36
		37	namespace Test {
		38	enum PlatformWheelPhase : uint64_t;
		39	}
		40
37	namespace WebCore {	41	namespace WebCore {
38	class PlatformWheelEvent;	42	class PlatformWheelEvent;
39	enum PlatformWheelEventPhase : uint64_t;
40	}	43	}
41		44
42		45
Lines 45-51 class HandleWheelEvent; a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h_sec2
45	} // namespace Test	48	} // namespace Test
46		49
47	namespace JSC {	50	namespace JSC {
48	template<> struct InputTraits<Test::HandleWheelEvent> {	51	template<> struct TEST_EXPORT_MACRO InputTraits<Test::HandleWheelEvent> {
49	static InputQueue queue() { return InputQueue::EventLoopInput; }	52	static InputQueue queue() { return InputQueue::EventLoopInput; }
50	static const String& type();	53	static const String& type();
51		54
Lines 53-63 template<> struct InputTraits<Test::HandleWheelEvent> { a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h_sec3
53	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::HandleWheelEvent>&);	56	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::HandleWheelEvent>&);
54	};	57	};
55	#if ENABLE(DUMMY_FEATURE)	58	#if ENABLE(DUMMY_FEATURE)
56	template<> struct EncodingTraits<WebCore::PlatformWheelEventPhase> {	59	template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::PlatformWheelPhase> {
57	typedef WebCore::PlatformWheelEventPhase DecodedType;	60	typedef Test::PlatformWheelPhase DecodedType;
58		61
59	static EncodedValue encodeValue(const WebCore::PlatformWheelEventPhase& value);	62	static EncodedValue encodeValue(const Test::PlatformWheelPhase& value);
60	static bool decodeValue(EncodedValue&, WebCore::PlatformWheelEventPhase& value);	63	static bool decodeValue(EncodedValue&, Test::PlatformWheelPhase& value);
61	};	64	};
62	#endif // ENABLE(DUMMY_FEATURE)	65	#endif // ENABLE(DUMMY_FEATURE)
63	} // namespace JSC	66	} // namespace JSC
Lines 65-78 template<> struct EncodingTraits<WebCore::PlatformWheelEventPhase> { a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enum-with-guard.json-TestReplayInputs.h_sec4
65	namespace Test {	68	namespace Test {
66	class HandleWheelEvent : public EventLoopInput<HandleWheelEvent> {	69	class HandleWheelEvent : public EventLoopInput<HandleWheelEvent> {
67	public:	70	public:
68	HandleWheelEvent(std::unique_ptr<PlatformWheelEvent> platformEvent);	71	TEST_EXPORT_MACRO HandleWheelEvent(std::unique_ptr<PlatformWheelEvent> platformEvent, PlatformWheelPhase phase);
69	virtual ~HandleWheelEvent();	72	virtual ~HandleWheelEvent();
70		73
71	// EventLoopInput API	74	// EventLoopInput API
72	virtual void dispatch(ReplayController&) override final;	75	virtual void dispatch(ReplayController&) override final;
73	const PlatformWheelEvent& platformEvent() const { return *m_platformEvent; }	76	const PlatformWheelEvent& platformEvent() const { return *m_platformEvent; }
		77	PlatformWheelPhase phase() const { return m_phase; }
74	private:	78	private:
75	std::unique_ptr<PlatformWheelEvent> m_platformEvent;	79	std::unique_ptr<PlatformWheelEvent> m_platformEvent;
		80	PlatformWheelPhase m_phase;
76	};	81	};
77	} // namespace Test	82	} // namespace Test
78		83

Lines 60-67 void InputTraits<Test::FormCombo>::encode(EncodedValue& encodedValue, const Test a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp -75 / +20 lines
60	{	60	{
61	encodedValue.put<PlatformEvent1::Type>(ASCIILiteral("eventType1"), input.eventType1());	61	encodedValue.put<PlatformEvent1::Type>(ASCIILiteral("eventType1"), input.eventType1());
62	encodedValue.put<PlatformEvent2::Type>(ASCIILiteral("eventType2"), input.eventType2());	62	encodedValue.put<PlatformEvent2::Type>(ASCIILiteral("eventType2"), input.eventType2());
63	encodedValue.put<WebCore::FormData1::Type>(ASCIILiteral("formType1"), input.formType1());	63	encodedValue.put<Test::FormData1::Type>(ASCIILiteral("formType1"), input.formType1());
64	encodedValue.put<WebCore::FormData2::Type>(ASCIILiteral("formType2"), input.formType2());	64	encodedValue.put<Test::FormData2::Type>(ASCIILiteral("formType2"), input.formType2());
65	}	65	}
66		66
67	bool InputTraits<Test::FormCombo>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::FormCombo>& input)	67	bool InputTraits<Test::FormCombo>::decode(EncodedValue& encodedValue, std::unique_ptr<Test::FormCombo>& input)
Lines 74-107 bool InputTraits<Test::FormCombo>::decode(EncodedValue& encodedValue, std::uniqu a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp_sec2
74	if (!encodedValue.get<PlatformEvent2::Type>(ASCIILiteral("eventType2"), eventType2))	74	if (!encodedValue.get<PlatformEvent2::Type>(ASCIILiteral("eventType2"), eventType2))
75	return false;	75	return false;
76		76
77	WebCore::FormData1::Type formType1;	77	Test::FormData1::Type formType1;
78	if (!encodedValue.get<WebCore::FormData1::Type>(ASCIILiteral("formType1"), formType1))	78	if (!encodedValue.get<Test::FormData1::Type>(ASCIILiteral("formType1"), formType1))
79	return false;	79	return false;
80		80
81	WebCore::FormData2::Type formType2;	81	Test::FormData2::Type formType2;
82	if (!encodedValue.get<WebCore::FormData2::Type>(ASCIILiteral("formType2"), formType2))	82	if (!encodedValue.get<Test::FormData2::Type>(ASCIILiteral("formType2"), formType2))
83	return false;	83	return false;
84		84
85	input = std::make_unique<Test::FormCombo>(eventType1, eventType2, formType1, formType2);	85	input = std::make_unique<Test::FormCombo>(eventType1, eventType2, formType1, formType2);
86	return true;	86	return true;
87	}	87	}
88	EncodedValue EncodingTraits<WebCore::FormData1::Type>::encodeValue(const WebCore::FormData1::Type& enumValue)	88	EncodedValue EncodingTraits<Test::FormData1::Type>::encodeValue(const Test::FormData1::Type& enumValue)
89	{	89	{
90	EncodedValue encodedValue = EncodedValue::createArray();	90	EncodedValue encodedValue = EncodedValue::createArray();
91	if (enumValue & WebCore::FormData1::Text) {	91	if (enumValue & Test::FormData1::Text) {
92	encodedValue.append<String>(ASCIILiteral("Text"));	92	encodedValue.append<String>(ASCIILiteral("Text"));
93	if (enumValue == WebCore::FormData1::Text)	93	if (enumValue == Test::FormData1::Text)
94	return encodedValue;	94	return encodedValue;
95	}	95	}
96	if (enumValue & WebCore::FormData1::Blob) {	96	if (enumValue & Test::FormData1::Blob) {
97	encodedValue.append<String>(ASCIILiteral("Blob"));	97	encodedValue.append<String>(ASCIILiteral("Blob"));
98	if (enumValue == WebCore::FormData1::Blob)	98	if (enumValue == Test::FormData1::Blob)
99	return encodedValue;	99	return encodedValue;
100	}	100	}
101	return encodedValue;	101	return encodedValue;
102	}	102	}
103		103
104	bool EncodingTraits<WebCore::FormData1::Type>::decodeValue(EncodedValue& encodedValue, WebCore::FormData1::Type& enumValue)	104	bool EncodingTraits<Test::FormData1::Type>::decodeValue(EncodedValue& encodedValue, Test::FormData1::Type& enumValue)
105	{	105	{
106	Vector<String> enumStrings;	106	Vector<String> enumStrings;
107	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))	107	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
Lines 109-195 bool EncodingTraits<WebCore::FormData1::Type>::decodeValue(EncodedValue& encoded a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.cpp_sec3
109		109
110	for (const String& enumString : enumStrings) {	110	for (const String& enumString : enumStrings) {
111	if (enumString == "Text")	111	if (enumString == "Text")
112	enumValue = static_cast<WebCore::FormData1::Type>(enumValue \| WebCore::FormData1::Text);	112	enumValue = static_cast<Test::FormData1::Type>(enumValue \| Test::FormData1::Text);
113	else if (enumString == "Blob")	113	else if (enumString == "Blob")
114	enumValue = static_cast<WebCore::FormData1::Type>(enumValue \| WebCore::FormData1::Blob);	114	enumValue = static_cast<Test::FormData1::Type>(enumValue \| Test::FormData1::Blob);
115	}	115	}
116		116
117	return true;	117	return true;
118	}	118	}
119		119
120	EncodedValue EncodingTraits<WebCore::FormData2::Type>::encodeValue(const WebCore::FormData2::Type& enumValue)	120	EncodedValue EncodingTraits<Test::FormData2::Type>::encodeValue(const Test::FormData2::Type& enumValue)
121	{	121	{
122	switch (enumValue) {	122	switch (enumValue) {
123	case WebCore::FormData2::Type::Text: return EncodedValue::createString("Text");	123	case Test::FormData2::Type::Text: return EncodedValue::createString("Text");
124	case WebCore::FormData2::Type::Blob: return EncodedValue::createString("Blob");	124	case Test::FormData2::Type::Blob: return EncodedValue::createString("Blob");
125	default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");	125	default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
126	}	126	}
127	}	127	}
128		128
129	bool EncodingTraits<WebCore::FormData2::Type>::decodeValue(EncodedValue& encodedValue, WebCore::FormData2::Type& enumValue)	129	bool EncodingTraits<Test::FormData2::Type>::decodeValue(EncodedValue& encodedValue, Test::FormData2::Type& enumValue)
130	{	130	{
131	String enumString = encodedValue.convertTo<String>();	131	String enumString = encodedValue.convertTo<String>();
132	if (enumString == "Text") {	132	if (enumString == "Text") {
133	enumValue = WebCore::FormData2::Type::Text;	133	enumValue = Test::FormData2::Type::Text;
134	return true;	134	return true;
135	}	135	}
136	if (enumString == "Blob") {	136	if (enumString == "Blob") {
137	enumValue = WebCore::FormData2::Type::Blob;	137	enumValue = Test::FormData2::Type::Blob;
138	return true;
139	}
140	return false;
141	}
142
143	EncodedValue EncodingTraits<PlatformEvent1::Type>::encodeValue(const PlatformEvent1::Type& enumValue)
144	{
145	EncodedValue encodedValue = EncodedValue::createArray();
146	if (enumValue & PlatformEvent1::Mouse) {
147	encodedValue.append<String>(ASCIILiteral("Mouse"));
148	if (enumValue == PlatformEvent1::Mouse)
149	return encodedValue;
150	}
151	if (enumValue & PlatformEvent1::Keyboard) {
152	encodedValue.append<String>(ASCIILiteral("Keyboard"));
153	if (enumValue == PlatformEvent1::Keyboard)
154	return encodedValue;
155	}
156	return encodedValue;
157	}
158
159	bool EncodingTraits<PlatformEvent1::Type>::decodeValue(EncodedValue& encodedValue, PlatformEvent1::Type& enumValue)
160	{
161	Vector<String> enumStrings;
162	if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
163	return false;
164
165	for (const String& enumString : enumStrings) {
166	if (enumString == "Mouse")
167	enumValue = static_cast<PlatformEvent1::Type>(enumValue \| PlatformEvent1::Mouse);
168	else if (enumString == "Keyboard")
169	enumValue = static_cast<PlatformEvent1::Type>(enumValue \| PlatformEvent1::Keyboard);
170	}
171
172	return true;
173	}
174
175	EncodedValue EncodingTraits<PlatformEvent2::Type>::encodeValue(const PlatformEvent2::Type& enumValue)
176	{
177	switch (enumValue) {
178	case PlatformEvent2::Type::Mouse: return EncodedValue::createString("Mouse");
179	case PlatformEvent2::Type::Keyboard: return EncodedValue::createString("Keyboard");
180	default: ASSERT_NOT_REACHED(); return EncodedValue::createString("Error!");
181	}
182	}
183
184	bool EncodingTraits<PlatformEvent2::Type>::decodeValue(EncodedValue& encodedValue, PlatformEvent2::Type& enumValue)
185	{
186	String enumString = encodedValue.convertTo<String>();
187	if (enumString == "Mouse") {
188	enumValue = PlatformEvent2::Type::Mouse;
189	return true;
190	}
191	if (enumString == "Keyboard") {
192	enumValue = PlatformEvent2::Type::Keyboard;
193	return true;	138	return true;
194	}	139	}
195	return false;	140	return false;

Lines 31-40 a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.h_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.h -26 / +12 lines
31	#define generate_enums_with_same_base_name_json_TestReplayInputs_h	31	#define generate_enums_with_same_base_name_json_TestReplayInputs_h
32		32
33	#if ENABLE(WEB_REPLAY)	33	#if ENABLE(WEB_REPLAY)
		34	#include "FormData1.h"
		35	#include "FormData2.h"
34	#include "InternalNamespaceHeaderIncludeDummy.h"	36	#include "InternalNamespaceHeaderIncludeDummy.h"
35	#include <platform/ExternalNamespaceHeaderIncludeDummy.h>	37	#include <platform/ExternalNamespaceHeaderIncludeDummy.h>
36	#include <replay/FormData1.h>
37	#include <replay/FormData2.h>
38	#include <replay/PlatformEvent.h>	38	#include <replay/PlatformEvent.h>
39		39
40		40
Lines 44-89 class FormCombo; a/Source/JavaScriptCore/replay/scripts/tests/expected/generate-enums-with-same-base-name.json-TestReplayInputs.h_sec2
44	} // namespace Test	44	} // namespace Test
45		45
46	namespace JSC {	46	namespace JSC {
47	template<> struct InputTraits<Test::FormCombo> {	47	template<> struct TEST_EXPORT_MACRO InputTraits<Test::FormCombo> {
48	static InputQueue queue() { return InputQueue::ScriptMemoizedData; }	48	static InputQueue queue() { return InputQueue::ScriptMemoizedData; }
49	static const String& type();	49	static const String& type();
50		50
51	static void encode(JSC::EncodedValue&, const Test::FormCombo&);	51	static void encode(JSC::EncodedValue&, const Test::FormCombo&);
52	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::FormCombo>&);	52	static bool decode(JSC::EncodedValue&, std::unique_ptr<Test::FormCombo>&);
53	};	53	};
54	template<> struct EncodingTraits<WebCore::FormData1::Type> {	54	template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::FormData1::Type> {
55	typedef WebCore::FormData1::Type DecodedType;	55	typedef Test::FormData1::Type DecodedType;
56		56
57	static EncodedValue encodeValue(const WebCore::FormData1::Type& value);	57	static EncodedValue encodeValue(const Test::FormData1::Type& value);
58	static bool decodeValue(EncodedValue&, WebCore::FormData1::Type& value);	58	static bool decodeValue(EncodedValue&, Test::FormData1::Type& value);
59	};	59	};
60		60
61	template<> struct EncodingTraits<WebCore::FormData2::Type> {	61	template<> struct TEST_EXPORT_MACRO EncodingTraits<Test::FormData2::Type> {
62	typedef WebCore::FormData2::Type DecodedType;	62	typedef Test::FormData2::Type DecodedType;
63		63
64	static EncodedValue encodeValue(const WebCore::FormData2::Type& value);	64	static EncodedValue encodeValue(const Test::FormData2::Type& value);
65	static bool decodeValue(EncodedValue&, WebCore::FormData2::Type& value);	65	static bool decodeValue(EncodedValue&, Test::FormData2::Type& value);
66	};
67
68	template<> struct EncodingTraits<PlatformEvent1::Type> {
69	typedef PlatformEvent1::Type DecodedType;
70
71	static EncodedValue encodeValue(const PlatformEvent1::Type& value);
72	static bool decodeValue(EncodedValue&, PlatformEvent1::Type& value);
73	};
74
75	template<> struct EncodingTraits<PlatformEvent2::Type> {
76	typedef PlatformEvent2::Type DecodedType;
77
78	static EncodedValue encodeValue(const PlatformEvent2::Type& value);
79	static bool decodeValue(EncodedValue&, PlatformEvent2::Type& value);
80	};	66	};
81	} // namespace JSC	67	} // namespace JSC
82		68
83	namespace Test {	69	namespace Test {
84	class FormCombo : public NondeterministicInput<FormCombo> {	70	class FormCombo : public NondeterministicInput<FormCombo> {
85	public:	71	public:
86	FormCombo(PlatformEvent1::Type eventType1, PlatformEvent2::Type eventType2, FormData1::Type formType1, FormData2::Type formType2);	72	TEST_EXPORT_MACRO FormCombo(PlatformEvent1::Type eventType1, PlatformEvent2::Type eventType2, FormData1::Type formType1, FormData2::Type formType2);
87	virtual ~FormCombo();	73	virtual ~FormCombo();
88		74
89	PlatformEvent1::Type eventType1() const { return m_eventType1; }	75	PlatformEvent1::Type eventType1() const { return m_eventType1; }

Lines 1-14 a/Source/JavaScriptCore/replay/scripts/tests/generate-enum-encoding-helpers.json_sec1
- a/Source/JavaScriptCore/replay/scripts/tests/generate-enum-encoding-helpers.json -4 / +2 lines
1	{	1	{
2	"types": {	2	"types": {
3	"JavaScriptCore": [	3	"Test": [
4	{	4	{
5	"name": "InputQueue", "mode": "SCALAR",	5	"name": "InputQueue", "mode": "SCALAR",
6	"flags": ["ENUM_CLASS"],	6	"flags": ["ENUM_CLASS"],
7	"values": ["EventLoopInput", "LoaderMemoizedData", "ScriptMemoizedData"],	7	"values": ["EventLoopInput", "LoaderMemoizedData", "ScriptMemoizedData"],
8	"header": "replay/NondeterministicInput.h"	8	"header": "replay/NondeterministicInput.h"
9	}	9	},
10	],
11	"WebCore": [
12	{	10	{
13	"name": "MouseButton", "mode": "SCALAR", "storage": "unsigned",	11	"name": "MouseButton", "mode": "SCALAR", "storage": "unsigned",
14	"flags": ["ENUM"],	12	"flags": ["ENUM"],