Replace WTF::move with WTFMove
[WebKit-https.git] / Source / JavaScriptCore / replay / scripts / tests / expected / generate-enum-with-guard.json-TestReplayInputs.cpp
index 9a6d84a..486756e 100644 (file)
 
 #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)
+HandleWheelEvent::HandleWheelEvent(std::unique_ptr<PlatformWheelEvent> platformEvent, PlatformWheelPhase phase)
     : EventLoopInput<HandleWheelEvent>()
-    , m_platformEvent(std::move(platformEvent))
+    , m_platformEvent(WTFMove(platformEvent))
+    , m_phase(phase)
 {
 }
 
@@ -48,15 +50,16 @@ HandleWheelEvent::~HandleWheelEvent()
 } // namespace Test
 
 namespace JSC {
-const AtomicString& InputTraits<Test::HandleWheelEvent>::type()
+const String& InputTraits<Test::HandleWheelEvent>::type()
 {
-    static NeverDestroyed<const AtomicString> type("HandleWheelEvent", AtomicString::ConstructFromLiteral);
+    static NeverDestroyed<const String> type(ASCIILiteral("HandleWheelEvent"));
     return type;
 }
 
 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)
@@ -65,30 +68,34 @@ bool InputTraits<Test::HandleWheelEvent>::decode(EncodedValue& encodedValue, std
     if (!encodedValue.get<WebCore::PlatformWheelEvent>(ASCIILiteral("platformEvent"), platformEvent))
         return false;
 
-    input = std::make_unique<Test::HandleWheelEvent>(std::move(platformEvent));
+    Test::PlatformWheelPhase phase;
+    if (!encodedValue.get<Test::PlatformWheelPhase>(ASCIILiteral("phase"), phase))
+        return false;
+
+    input = std::make_unique<Test::HandleWheelEvent>(WTFMove(platformEvent), phase);
     return true;
 }
 #if ENABLE(DUMMY_FEATURE)
-EncodedValue EncodingTraits<WebCore::PlatformWheelEventPhase>::encodeValue(const WebCore::PlatformWheelEventPhase& enumValue)
+EncodedValue EncodingTraits<Test::PlatformWheelPhase>::encodeValue(const Test::PlatformWheelPhase& enumValue)
 {
     EncodedValue encodedValue = EncodedValue::createArray();
-    if (enumValue & WebCore::PlatformWheelEventPhaseNone) {
+    if (enumValue & Test::PlatformWheelEventPhaseNone) {
         encodedValue.append<String>(ASCIILiteral("PlatformWheelEventPhaseNone"));
-        if (enumValue == WebCore::PlatformWheelEventPhaseNone)
+        if (enumValue == Test::PlatformWheelEventPhaseNone)
             return encodedValue;
     }
     return encodedValue;
 }
 
-bool EncodingTraits<WebCore::PlatformWheelEventPhase>::decodeValue(EncodedValue& encodedValue, WebCore::PlatformWheelEventPhase& enumValue)
+bool EncodingTraits<Test::PlatformWheelPhase>::decodeValue(EncodedValue& encodedValue, Test::PlatformWheelPhase& enumValue)
 {
     Vector<String> enumStrings;
     if (!EncodingTraits<Vector<String>>::decodeValue(encodedValue, enumStrings))
         return false;
 
-    for (String enumString : enumStrings) {
+    for (const String& enumString : enumStrings) {
         if (enumString == "PlatformWheelEventPhaseNone")
-            enumValue = static_cast<WebCore::PlatformWheelEventPhase>(enumValue | WebCore::PlatformWheelEventPhaseNone);
+            enumValue = static_cast<Test::PlatformWheelPhase>(enumValue | Test::PlatformWheelEventPhaseNone);
     }
 
     return true;