[webkit-changes] [259937] trunk/Source/WebKit

Sat, 11 Apr 2020 16:58:26 -0700

Title: [259937] trunk/Source/WebKit
Revision
259937
Author
[email protected]
Date
2020-04-11 16:56:46 -0700 (Sat, 11 Apr 2020)

Log Message

Follow-up: Add WARN_UNUSED_RETURN to decode methods in WebCoreArgumentCoders
<https://webkit.org/b/210322>
<rdar://problem/61565148>

Changes based on feedback from Alex Christensen and Darin Adler:
- Remove WARN_UNUSED_RETURN from methods returning Optional<>.
- Place WARN_UNUSED_RETURN consistently before the return type.

* Shared/WebCoreArgumentCoders.cpp:
* Shared/WebCoreArgumentCoders.h:

Modified Paths

Diff

Modified: trunk/Source/WebKit/ChangeLog (259936 => 259937)


--- trunk/Source/WebKit/ChangeLog	2020-04-11 23:49:26 UTC (rev 259936)
+++ trunk/Source/WebKit/ChangeLog	2020-04-11 23:56:46 UTC (rev 259937)
@@ -1,3 +1,16 @@
+2020-04-11  David Kilzer  <[email protected]>
+
+        Follow-up: Add WARN_UNUSED_RETURN to decode methods in WebCoreArgumentCoders
+        <https://webkit.org/b/210322>
+        <rdar://problem/61565148>
+
+        Changes based on feedback from Alex Christensen and Darin Adler:
+        - Remove WARN_UNUSED_RETURN from methods returning Optional<>.
+        - Place WARN_UNUSED_RETURN consistently before the return type.
+
+        * Shared/WebCoreArgumentCoders.cpp:
+        * Shared/WebCoreArgumentCoders.h:
+
 2020-04-11  Daniel Bates  <[email protected]>
 
         Add text interaction delegate functions

Modified: trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp (259936 => 259937)


--- trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp	2020-04-11 23:49:26 UTC (rev 259936)
+++ trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp	2020-04-11 23:56:46 UTC (rev 259937)
@@ -1722,7 +1722,7 @@
 
 template<> struct ArgumentCoder<PasteboardCustomData::Entry> {
     static void encode(Encoder&, const PasteboardCustomData::Entry&);
-    static bool decode(Decoder&, PasteboardCustomData::Entry&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, PasteboardCustomData::Entry&);
 };
 
 void ArgumentCoder<PasteboardCustomData::Entry>::encode(Encoder& encoder, const PasteboardCustomData::Entry& data)

Modified: trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h (259936 => 259937)


--- trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h	2020-04-11 23:49:26 UTC (rev 259936)
+++ trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h	2020-04-11 23:56:46 UTC (rev 259937)
@@ -206,105 +206,105 @@
 
 template<> struct ArgumentCoder<WebCore::AffineTransform> {
     static void encode(Encoder&, const WebCore::AffineTransform&);
-    static bool decode(Decoder&, WebCore::AffineTransform&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AffineTransform&);
 };
 
 template<> struct ArgumentCoder<WebCore::CacheQueryOptions> {
     static void encode(Encoder&, const WebCore::CacheQueryOptions&);
-    static bool decode(Decoder&, WebCore::CacheQueryOptions&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CacheQueryOptions&);
 };
 
 template<> struct ArgumentCoder<WebCore::CharacterRange> {
     static void encode(Encoder&, const WebCore::CharacterRange&);
-    static Optional<WebCore::CharacterRange> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::CharacterRange> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::DOMCacheEngine::CacheInfo> {
     static void encode(Encoder&, const WebCore::DOMCacheEngine::CacheInfo&);
-    static Optional<WebCore::DOMCacheEngine::CacheInfo> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::DOMCacheEngine::CacheInfo> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::DOMCacheEngine::Record> {
     static void encode(Encoder&, const WebCore::DOMCacheEngine::Record&);
-    static Optional<WebCore::DOMCacheEngine::Record> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::DOMCacheEngine::Record> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::TouchActionData> {
     static void encode(Encoder&, const WebCore::TouchActionData&);
-    static Optional<WebCore::TouchActionData> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::TouchActionData> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::EventTrackingRegions> {
     static void encode(Encoder&, const WebCore::EventTrackingRegions&);
-    static bool decode(Decoder&, WebCore::EventTrackingRegions&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::EventTrackingRegions&);
 };
 
 template<> struct ArgumentCoder<WebCore::TransformationMatrix> {
     static void encode(Encoder&, const WebCore::TransformationMatrix&);
-    static bool decode(Decoder&, WebCore::TransformationMatrix&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::TransformationMatrix&);
 };
 
 template<> struct ArgumentCoder<WebCore::LinearTimingFunction> {
     static void encode(Encoder&, const WebCore::LinearTimingFunction&);
-    static bool decode(Decoder&, WebCore::LinearTimingFunction&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LinearTimingFunction&);
 };
 
 template<> struct ArgumentCoder<WebCore::CubicBezierTimingFunction> {
     static void encode(Encoder&, const WebCore::CubicBezierTimingFunction&);
-    static bool decode(Decoder&, WebCore::CubicBezierTimingFunction&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CubicBezierTimingFunction&);
 };
 
 template<> struct ArgumentCoder<WebCore::StepsTimingFunction> {
     static void encode(Encoder&, const WebCore::StepsTimingFunction&);
-    static bool decode(Decoder&, WebCore::StepsTimingFunction&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::StepsTimingFunction&);
 };
 
 template<> struct ArgumentCoder<WebCore::SpringTimingFunction> {
     static void encode(Encoder&, const WebCore::SpringTimingFunction&);
-    static bool decode(Decoder&, WebCore::SpringTimingFunction&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::SpringTimingFunction&);
 };
 
 template<> struct ArgumentCoder<WebCore::CertificateInfo> {
     static void encode(Encoder&, const WebCore::CertificateInfo&);
-    static bool decode(Decoder&, WebCore::CertificateInfo&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CertificateInfo&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatPoint> {
     static void encode(Encoder&, const WebCore::FloatPoint&);
-    static bool decode(Decoder&, WebCore::FloatPoint&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::FloatPoint> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatPoint&);
+    static Optional<WebCore::FloatPoint> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
     static void encode(Encoder&, const WebCore::FloatPoint3D&);
-    static bool decode(Decoder&, WebCore::FloatPoint3D&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatPoint3D&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatRect> {
     static void encode(Encoder&, const WebCore::FloatRect&);
-    static bool decode(Decoder&, WebCore::FloatRect&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::FloatRect> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatRect&);
+    static Optional<WebCore::FloatRect> decode(Decoder&);
 };
     
 template<> struct ArgumentCoder<WebCore::FloatBoxExtent> {
     static void encode(Encoder&, const WebCore::FloatBoxExtent&);
-    static bool decode(Decoder&, WebCore::FloatBoxExtent&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatBoxExtent&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatSize> {
     static void encode(Encoder&, const WebCore::FloatSize&);
-    static bool decode(Decoder&, WebCore::FloatSize&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatSize&);
 };
 
 template<> struct ArgumentCoder<WebCore::FloatRoundedRect> {
     static void encode(Encoder&, const WebCore::FloatRoundedRect&);
-    static bool decode(Decoder&, WebCore::FloatRoundedRect&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatRoundedRect&);
 };
 
 #if PLATFORM(IOS_FAMILY)
 template<> struct ArgumentCoder<WebCore::FloatQuad> {
     static void encode(Encoder&, const WebCore::FloatQuad&);
-    static Optional<WebCore::FloatQuad> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::FloatQuad> decode(Decoder&);
 };
 #endif // PLATFORM(IOS_FAMILY)
 
@@ -311,8 +311,8 @@
 #if ENABLE(META_VIEWPORT)
 template<> struct ArgumentCoder<WebCore::ViewportArguments> {
     static void encode(Encoder&, const WebCore::ViewportArguments&);
-    static bool decode(Decoder&, WebCore::ViewportArguments&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::ViewportArguments> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ViewportArguments&);
+    static Optional<WebCore::ViewportArguments> decode(Decoder&);
 };
 
 #endif
@@ -319,127 +319,127 @@
 
 template<> struct ArgumentCoder<WebCore::ViewportAttributes> {
     static void encode(Encoder&, const WebCore::ViewportAttributes&);
-    static bool decode(Decoder&, WebCore::ViewportAttributes&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ViewportAttributes&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntPoint> {
     static void encode(Encoder&, const WebCore::IntPoint&);
-    static bool decode(Decoder&, WebCore::IntPoint&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::IntPoint> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntPoint&);
+    static Optional<WebCore::IntPoint> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntRect> {
     static void encode(Encoder&, const WebCore::IntRect&);
-    static bool decode(Decoder&, WebCore::IntRect&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::IntRect> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntRect&);
+    static Optional<WebCore::IntRect> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::IntSize> {
     static void encode(Encoder&, const WebCore::IntSize&);
-    static bool decode(Decoder&, WebCore::IntSize&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::IntSize> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntSize&);
+    static Optional<WebCore::IntSize> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::LayoutSize> {
     static void encode(Encoder&, const WebCore::LayoutSize&);
-    static bool decode(Decoder&, WebCore::LayoutSize&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LayoutSize&);
 };
 
 template<> struct ArgumentCoder<WebCore::LayoutPoint> {
     static void encode(Encoder&, const WebCore::LayoutPoint&);
-    static bool decode(Decoder&, WebCore::LayoutPoint&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LayoutPoint&);
 };
 
 template<> struct ArgumentCoder<WebCore::Length> {
     static void encode(Encoder&, const WebCore::Length&);
-    static bool decode(Decoder&, WebCore::Length&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Length&);
 };
 
 template<> struct ArgumentCoder<WebCore::VelocityData> {
     static void encode(Encoder&, const WebCore::VelocityData&);
-    static bool decode(Decoder&, WebCore::VelocityData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::VelocityData&);
 };
 
 template<> struct ArgumentCoder<WebCore::MimeClassInfo> {
     static void encode(Encoder&, const WebCore::MimeClassInfo&);
-    static Optional<WebCore::MimeClassInfo> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::MimeClassInfo> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PluginInfo> {
     static void encode(Encoder&, const WebCore::PluginInfo&);
-    static Optional<WebCore::PluginInfo> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PluginInfo> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::AuthenticationChallenge> {
     static void encode(Encoder&, const WebCore::AuthenticationChallenge&);
-    static bool decode(Decoder&, WebCore::AuthenticationChallenge&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AuthenticationChallenge&);
 };
 
 template<> struct ArgumentCoder<WebCore::ProtectionSpace> {
     static void encode(Encoder&, const WebCore::ProtectionSpace&);
-    static bool decode(Decoder&, WebCore::ProtectionSpace&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ProtectionSpace&);
     static void encodePlatformData(Encoder&, const WebCore::ProtectionSpace&);
-    static bool decodePlatformData(Decoder&, WebCore::ProtectionSpace&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ProtectionSpace&);
 };
 
 template<> struct ArgumentCoder<WebCore::Credential> {
     static void encode(Encoder&, const WebCore::Credential&);
-    static bool decode(Decoder&, WebCore::Credential&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Credential&);
     static void encodePlatformData(Encoder&, const WebCore::Credential&);
-    static bool decodePlatformData(Decoder&, WebCore::Credential&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::Credential&);
 };
 
 template<> struct ArgumentCoder<WebCore::Cursor> {
     static void encode(Encoder&, const WebCore::Cursor&);
-    static bool decode(Decoder&, WebCore::Cursor&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Cursor&);
 };
 
 template<> struct ArgumentCoder<WebCore::FontHandle> {
     static void encode(Encoder&, const WebCore::FontHandle&);
-    static bool decode(Decoder&, WebCore::FontHandle&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FontHandle&);
     static void encodePlatformData(Encoder&, const WebCore::FontHandle&);
-    static bool decodePlatformData(Decoder&, WebCore::FontHandle&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::FontHandle&);
 };
 
 template<> struct ArgumentCoder<WebCore::ImageHandle> {
     static void encode(Encoder&, const WebCore::ImageHandle&);
-    static bool decode(Decoder&, WebCore::ImageHandle&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ImageHandle&);
 };
 
 template<> struct ArgumentCoder<WebCore::NativeImageHandle> {
     static void encode(Encoder&, const WebCore::NativeImageHandle&);
-    static bool decode(Decoder&, WebCore::NativeImageHandle&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::NativeImageHandle&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceRequest> {
     static void encode(Encoder&, const WebCore::ResourceRequest&);
-    static bool decode(Decoder&, WebCore::ResourceRequest&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ResourceRequest&);
     static void encodePlatformData(Encoder&, const WebCore::ResourceRequest&);
-    static bool decodePlatformData(Decoder&, WebCore::ResourceRequest&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ResourceRequest&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceError> {
     static void encode(Encoder&, const WebCore::ResourceError&);
-    static bool decode(Decoder&, WebCore::ResourceError&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ResourceError&);
     static void encodePlatformData(Encoder&, const WebCore::ResourceError&);
-    static bool decodePlatformData(Decoder&, WebCore::ResourceError&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ResourceError&);
 };
 
 template<> struct ArgumentCoder<WebCore::WindowFeatures> {
     static void encode(Encoder&, const WebCore::WindowFeatures&);
-    static bool decode(Decoder&, WebCore::WindowFeatures&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::WindowFeatures&);
 };
 
 template<> struct ArgumentCoder<WebCore::Color> {
     static void encode(Encoder&, const WebCore::Color&);
-    static bool decode(Decoder&, WebCore::Color&) WARN_UNUSED_RETURN;
-    static Optional<WebCore::Color> decode(Decoder&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Color&);
+    static Optional<WebCore::Color> decode(Decoder&);
 };
 
 #if ENABLE(DRAG_SUPPORT)
 template<> struct ArgumentCoder<WebCore::DragData> {
     static void encode(Encoder&, const WebCore::DragData&);
-    static bool decode(Decoder&, WebCore::DragData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DragData&);
 };
 #endif
 
@@ -447,32 +447,32 @@
 template<> struct ArgumentCoder<WTF::MachSendRight> {
     static void encode(Encoder&, const WTF::MachSendRight&);
     static void encode(Encoder&, WTF::MachSendRight&&);
-    static bool decode(Decoder&, WTF::MachSendRight&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WTF::MachSendRight&);
 };
 
 template<> struct ArgumentCoder<WebCore::KeypressCommand> {
     static void encode(Encoder&, const WebCore::KeypressCommand&);
-    static Optional<WebCore::KeypressCommand> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::KeypressCommand> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<CGPoint> {
     static void encode(Encoder&, CGPoint);
-    static Optional<CGPoint> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<CGPoint> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<CGSize> {
     static void encode(Encoder&, CGSize);
-    static Optional<CGSize> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<CGSize> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<CGRect> {
     static void encode(Encoder&, CGRect);
-    static Optional<CGRect> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<CGRect> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<CGAffineTransform> {
     static void encode(Encoder&, CGAffineTransform);
-    static Optional<CGAffineTransform> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<CGAffineTransform> decode(Decoder&);
 };
 #endif
 
@@ -479,39 +479,39 @@
 #if PLATFORM(IOS_FAMILY)
 template<> struct ArgumentCoder<WebCore::SelectionRect> {
     static void encode(Encoder&, const WebCore::SelectionRect&);
-    static Optional<WebCore::SelectionRect> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::SelectionRect> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::Highlight> {
     static void encode(Encoder&, const WebCore::Highlight&);
-    static bool decode(Decoder&, WebCore::Highlight&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Highlight&);
 };
 
 template<> struct ArgumentCoder<WebCore::PasteboardWebContent> {
     static void encode(Encoder&, const WebCore::PasteboardWebContent&);
-    static bool decode(Decoder&, WebCore::PasteboardWebContent&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardWebContent&);
 };
 
 template<> struct ArgumentCoder<WebCore::PasteboardImage> {
     static void encode(Encoder&, const WebCore::PasteboardImage&);
-    static bool decode(Decoder&, WebCore::PasteboardImage&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardImage&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::PasteboardCustomData> {
     static void encode(Encoder&, const WebCore::PasteboardCustomData&);
-    static bool decode(Decoder&, WebCore::PasteboardCustomData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardCustomData&);
 };
 
 template<> struct ArgumentCoder<WebCore::PasteboardURL> {
     static void encode(Encoder&, const WebCore::PasteboardURL&);
-    static bool decode(Decoder&, WebCore::PasteboardURL&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardURL&);
 };
 
 #if USE(SOUP)
 template<> struct ArgumentCoder<WebCore::SoupNetworkProxySettings> {
     static void encode(Encoder&, const WebCore::SoupNetworkProxySettings&);
-    static bool decode(Decoder&, WebCore::SoupNetworkProxySettings&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::SoupNetworkProxySettings&);
 };
 #endif
 
@@ -518,7 +518,7 @@
 #if USE(LIBWPE)
 template<> struct ArgumentCoder<WebCore::PasteboardWebContent> {
     static void encode(Encoder&, const WebCore::PasteboardWebContent&);
-    static bool decode(Decoder&, WebCore::PasteboardWebContent&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardWebContent&);
 };
 #endif
 
@@ -525,101 +525,101 @@
 #if USE(CURL)
 template<> struct ArgumentCoder<WebCore::CurlProxySettings> {
     static void encode(Encoder&, const WebCore::CurlProxySettings&);
-    static Optional<WebCore::CurlProxySettings> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::CurlProxySettings> decode(Decoder&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::CompositionUnderline> {
     static void encode(Encoder&, const WebCore::CompositionUnderline&);
-    static Optional<WebCore::CompositionUnderline> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::CompositionUnderline> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::DatabaseDetails> {
     static void encode(Encoder&, const WebCore::DatabaseDetails&);
-    static bool decode(Decoder&, WebCore::DatabaseDetails&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DatabaseDetails&);
 };
 
 template<> struct ArgumentCoder<WebCore::DictationAlternative> {
     static void encode(Encoder&, const WebCore::DictationAlternative&);
-    static Optional<WebCore::DictationAlternative> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::DictationAlternative> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::FileChooserSettings> {
     static void encode(Encoder&, const WebCore::FileChooserSettings&);
-    static bool decode(Decoder&, WebCore::FileChooserSettings&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FileChooserSettings&);
 };
     
 template<> struct ArgumentCoder<WebCore::ShareData> {
     static void encode(Encoder&, const WebCore::ShareData&);
-    static bool decode(Decoder&, WebCore::ShareData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ShareData&);
 };
     
 template<> struct ArgumentCoder<WebCore::ShareDataWithParsedURL> {
     static void encode(Encoder&, const WebCore::ShareDataWithParsedURL&);
-    static bool decode(Decoder&, WebCore::ShareDataWithParsedURL&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ShareDataWithParsedURL&);
 };
 
 template<> struct ArgumentCoder<WebCore::GrammarDetail> {
     static void encode(Encoder&, const WebCore::GrammarDetail&);
-    static Optional<WebCore::GrammarDetail> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::GrammarDetail> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::TextCheckingRequestData> {
     static void encode(Encoder&, const WebCore::TextCheckingRequestData&);
-    static bool decode(Decoder&, WebCore::TextCheckingRequestData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::TextCheckingRequestData&);
 };
 
 template<> struct ArgumentCoder<WebCore::TextCheckingResult> {
     static void encode(Encoder&, const WebCore::TextCheckingResult&);
-    static Optional<WebCore::TextCheckingResult> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::TextCheckingResult> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::UserStyleSheet> {
     static void encode(Encoder&, const WebCore::UserStyleSheet&);
-    static bool decode(Decoder&, WebCore::UserStyleSheet&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::UserStyleSheet&);
 };
 
 template<> struct ArgumentCoder<WebCore::ScrollableAreaParameters> {
     static void encode(Encoder&, const WebCore::ScrollableAreaParameters&);
-    static bool decode(Decoder&, WebCore::ScrollableAreaParameters&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ScrollableAreaParameters&);
 };
 
 template<> struct ArgumentCoder<WebCore::FixedPositionViewportConstraints> {
     static void encode(Encoder&, const WebCore::FixedPositionViewportConstraints&);
-    static bool decode(Decoder&, WebCore::FixedPositionViewportConstraints&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FixedPositionViewportConstraints&);
 };
 
 template<> struct ArgumentCoder<WebCore::StickyPositionViewportConstraints> {
     static void encode(Encoder&, const WebCore::StickyPositionViewportConstraints&);
-    static bool decode(Decoder&, WebCore::StickyPositionViewportConstraints&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::StickyPositionViewportConstraints&);
 };
 
 template<> struct ArgumentCoder<WebCore::AbsolutePositionConstraints> {
     static void encode(Encoder&, const WebCore::AbsolutePositionConstraints&);
-    static bool decode(Decoder&, WebCore::AbsolutePositionConstraints&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AbsolutePositionConstraints&);
 };
 
 #if !USE(COORDINATED_GRAPHICS)
 template<> struct ArgumentCoder<WebCore::FilterOperations> {
     static void encode(Encoder&, const WebCore::FilterOperations&);
-    static bool decode(Decoder&, WebCore::FilterOperations&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FilterOperations&);
 };
     
 template<> struct ArgumentCoder<WebCore::FilterOperation> {
     static void encode(Encoder&, const WebCore::FilterOperation&);
 };
-bool decodeFilterOperation(Decoder&, RefPtr<WebCore::FilterOperation>&) WARN_UNUSED_RETURN;
+WARN_UNUSED_RETURN bool decodeFilterOperation(Decoder&, RefPtr<WebCore::FilterOperation>&);
 #endif
 
 template<> struct ArgumentCoder<WebCore::BlobPart> {
     static void encode(Encoder&, const WebCore::BlobPart&);
-    static Optional<WebCore::BlobPart> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::BlobPart> decode(Decoder&);
 };
 
 #if ENABLE(CONTENT_FILTERING)
 template<> struct ArgumentCoder<WebCore::ContentFilterUnblockHandler> {
     static void encode(Encoder&, const WebCore::ContentFilterUnblockHandler&);
-    static bool decode(Decoder&, WebCore::ContentFilterUnblockHandler&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ContentFilterUnblockHandler&);
 };
 #endif
 
@@ -626,44 +626,44 @@
 #if ENABLE(MEDIA_SESSION)
 template<> struct ArgumentCoder<WebCore::MediaSessionMetadata> {
     static void encode(Encoder&, const WebCore::MediaSessionMetadata&);
-    static bool decode(Decoder&, WebCore::MediaSessionMetadata&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaSessionMetadata&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::TextIndicatorData> {
     static void encode(Encoder&, const WebCore::TextIndicatorData&);
-    static Optional<WebCore::TextIndicatorData> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::TextIndicatorData> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::DictionaryPopupInfo> {
     static void encode(Encoder&, const WebCore::DictionaryPopupInfo&);
-    static bool decode(Decoder&, WebCore::DictionaryPopupInfo&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DictionaryPopupInfo&);
     static void encodePlatformData(Encoder&, const WebCore::DictionaryPopupInfo&);
-    static bool decodePlatformData(Decoder&, WebCore::DictionaryPopupInfo&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::DictionaryPopupInfo&);
 };
 
 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
 template<> struct ArgumentCoder<WebCore::MediaPlaybackTargetContext> {
     static void encode(Encoder&, const WebCore::MediaPlaybackTargetContext&);
-    static bool decode(Decoder&, WebCore::MediaPlaybackTargetContext&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaPlaybackTargetContext&);
     static void encodePlatformData(Encoder&, const WebCore::MediaPlaybackTargetContext&);
-    static bool decodePlatformData(Decoder&, WebCore::MediaPlaybackTargetContext&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::MediaPlaybackTargetContext&);
 };
 #endif
 
 template<> struct ArgumentCoder<WebCore::RecentSearch> {
     static void encode(Encoder&, const WebCore::RecentSearch&);
-    static Optional<WebCore::RecentSearch> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::RecentSearch> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ExceptionDetails> {
     static void encode(Encoder&, const WebCore::ExceptionDetails&);
-    static bool decode(Decoder&, WebCore::ExceptionDetails&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ExceptionDetails&);
 };
 
 template<> struct ArgumentCoder<WebCore::ResourceLoadStatistics> {
     static void encode(Encoder&, const WebCore::ResourceLoadStatistics&);
-    static Optional<WebCore::ResourceLoadStatistics> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ResourceLoadStatistics> decode(Decoder&);
 };
 
 #if ENABLE(APPLE_PAY)
@@ -670,82 +670,82 @@
 
 template<> struct ArgumentCoder<WebCore::Payment> {
     static void encode(Encoder&, const WebCore::Payment&);
-    static Optional<WebCore::Payment> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::Payment> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentAuthorizationResult> {
     static void encode(Encoder&, const WebCore::PaymentAuthorizationResult&);
-    static Optional<WebCore::PaymentAuthorizationResult> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentAuthorizationResult> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentContact> {
     static void encode(Encoder&, const WebCore::PaymentContact&);
-    static Optional<WebCore::PaymentContact> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentContact> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentError> {
     static void encode(Encoder&, const WebCore::PaymentError&);
-    static Optional<WebCore::PaymentError> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentError> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentMerchantSession> {
     static void encode(Encoder&, const WebCore::PaymentMerchantSession&);
-    static Optional<WebCore::PaymentMerchantSession> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentMerchantSession> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentMethod> {
     static void encode(Encoder&, const WebCore::PaymentMethod&);
-    static Optional<WebCore::PaymentMethod> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentMethod> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentMethodUpdate> {
     static void encode(Encoder&, const WebCore::PaymentMethodUpdate&);
-    static Optional<WebCore::PaymentMethodUpdate> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentMethodUpdate> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest&);
-    static bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::ContactFields> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::ContactFields&);
-    static bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::ContactFields&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::ContactFields&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::LineItem> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::LineItem&);
-    static Optional<WebCore::ApplePaySessionPaymentRequest::LineItem> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ApplePaySessionPaymentRequest::LineItem> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities&);
-    static bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::ShippingMethod> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::ShippingMethod&);
-    static Optional<WebCore::ApplePaySessionPaymentRequest::ShippingMethod> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ApplePaySessionPaymentRequest::ShippingMethod> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems> {
     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems&);
-    static Optional<WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ShippingContactUpdate> {
     static void encode(Encoder&, const WebCore::ShippingContactUpdate&);
-    static Optional<WebCore::ShippingContactUpdate> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ShippingContactUpdate> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::ShippingMethodUpdate> {
     static void encode(Encoder&, const WebCore::ShippingMethodUpdate&);
-    static Optional<WebCore::ShippingMethodUpdate> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ShippingMethodUpdate> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PaymentSessionError> {
     static void encode(Encoder&, const WebCore::PaymentSessionError&);
-    static Optional<WebCore::PaymentSessionError> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::PaymentSessionError> decode(Decoder&);
 };
 
 #endif
@@ -753,7 +753,7 @@
 #if ENABLE(MEDIA_STREAM)
 template<> struct ArgumentCoder<WebCore::MediaConstraints> {
     static void encode(Encoder&, const WebCore::MediaConstraints&);
-    static bool decode(Decoder&, WebCore::MediaConstraints&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaConstraints&);
 };
 #endif
 
@@ -761,7 +761,7 @@
 
 template<> struct ArgumentCoder<WebCore::IDBKeyPath> {
     static void encode(Encoder&, const WebCore::IDBKeyPath&);
-    static bool decode(Decoder&, WebCore::IDBKeyPath&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IDBKeyPath&);
 };
 
 #endif
@@ -770,12 +770,12 @@
 
 template<> struct ArgumentCoder<WebCore::ServiceWorkerOrClientData> {
     static void encode(Encoder&, const WebCore::ServiceWorkerOrClientData&);
-    static bool decode(Decoder&, WebCore::ServiceWorkerOrClientData&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ServiceWorkerOrClientData&);
 };
 
 template<> struct ArgumentCoder<WebCore::ServiceWorkerOrClientIdentifier> {
     static void encode(Encoder&, const WebCore::ServiceWorkerOrClientIdentifier&);
-    static bool decode(Decoder&, WebCore::ServiceWorkerOrClientIdentifier&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ServiceWorkerOrClientIdentifier&);
 };
 
 #endif
@@ -784,7 +784,7 @@
 
 template<> struct ArgumentCoder<WebCore::ScrollOffsetRange<float>> {
     static void encode(Encoder&, const WebCore::ScrollOffsetRange<float>&);
-    static Optional<WebCore::ScrollOffsetRange<float>> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::ScrollOffsetRange<float>> decode(Decoder&);
 };
 
 #endif
@@ -791,24 +791,24 @@
 
 template<> struct ArgumentCoder<WebCore::MediaSelectionOption> {
     static void encode(Encoder&, const WebCore::MediaSelectionOption&);
-    static Optional<WebCore::MediaSelectionOption> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::MediaSelectionOption> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::PromisedAttachmentInfo> {
     static void encode(Encoder&, const WebCore::PromisedAttachmentInfo&);
-    static bool decode(Decoder&, WebCore::PromisedAttachmentInfo&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PromisedAttachmentInfo&);
 };
 
 template<> struct ArgumentCoder<Vector<RefPtr<WebCore::SecurityOrigin>>> {
     static void encode(Encoder&, const Vector<RefPtr<WebCore::SecurityOrigin>>&);
-    static bool decode(Decoder&, Vector<RefPtr<WebCore::SecurityOrigin>>&) WARN_UNUSED_RETURN;
+    static WARN_UNUSED_RETURN bool decode(Decoder&, Vector<RefPtr<WebCore::SecurityOrigin>>&);
 };
 
 template<> struct ArgumentCoder<WebCore::FontAttributes> {
     static void encode(Encoder&, const WebCore::FontAttributes&);
-    static Optional<WebCore::FontAttributes> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::FontAttributes> decode(Decoder&);
     static void encodePlatformData(Encoder&, const WebCore::FontAttributes&);
-    static Optional<WebCore::FontAttributes> decodePlatformData(Decoder&, WebCore::FontAttributes&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::FontAttributes> decodePlatformData(Decoder&, WebCore::FontAttributes&);
 };
 
 #if ENABLE(ATTACHMENT_ELEMENT)
@@ -815,7 +815,7 @@
 
 template<> struct ArgumentCoder<WebCore::SerializedAttachmentData> {
     static void encode(Encoder&, const WebCore::SerializedAttachmentData&);
-    static Optional<WebCore::SerializedAttachmentData> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::SerializedAttachmentData> decode(Decoder&);
 };
 
 #endif // ENABLE(ATTACHMENT_ELEMENT)
@@ -823,42 +823,42 @@
 #if ENABLE(VIDEO)
 template<> struct ArgumentCoder<WebCore::SerializedPlatformDataCueValue> {
     static void encode(Encoder&, const WebCore::SerializedPlatformDataCueValue&);
-    static Optional<WebCore::SerializedPlatformDataCueValue> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::SerializedPlatformDataCueValue> decode(Decoder&);
     static void encodePlatformData(Encoder&, const WebCore::SerializedPlatformDataCueValue&);
-    static Optional<WebCore::SerializedPlatformDataCueValue> decodePlatformData(Decoder&, WebCore::SerializedPlatformDataCueValue::PlatformType) WARN_UNUSED_RETURN;
+    static Optional<WebCore::SerializedPlatformDataCueValue> decodePlatformData(Decoder&, WebCore::SerializedPlatformDataCueValue::PlatformType);
 };
 #endif
 
 template<> struct ArgumentCoder<RefPtr<WebCore::SharedBuffer>> {
     static void encode(Encoder&, const RefPtr<WebCore::SharedBuffer>&);
-    static Optional<RefPtr<WebCore::SharedBuffer>> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<RefPtr<WebCore::SharedBuffer>> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<Ref<WebCore::SharedBuffer>> {
     static void encode(Encoder&, const Ref<WebCore::SharedBuffer>&);
-    static Optional<Ref<WebCore::SharedBuffer>> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<Ref<WebCore::SharedBuffer>> decode(Decoder&);
 };
 
 #if ENABLE(ENCRYPTED_MEDIA)
 template<> struct ArgumentCoder<WebCore::CDMInstanceSession::Message> {
     static void encode(Encoder&, const WebCore::CDMInstanceSession::Message&);
-    static Optional<WebCore::CDMInstanceSession::Message> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::CDMInstanceSession::Message> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<WebCore::CDMInstanceSession::KeyStatusVector> {
     static void encode(Encoder&, const WebCore::CDMInstanceSession::KeyStatusVector&);
-    static Optional<WebCore::CDMInstanceSession::KeyStatusVector> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<WebCore::CDMInstanceSession::KeyStatusVector> decode(Decoder&);
 };
 #endif
 
 template<> struct ArgumentCoder<RefPtr<WebCore::ImageData>> {
     static void encode(Encoder&, const RefPtr<WebCore::ImageData>&);
-    static Optional<RefPtr<WebCore::ImageData>> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<RefPtr<WebCore::ImageData>> decode(Decoder&);
 };
 
 template<> struct ArgumentCoder<Ref<WebCore::ImageData>> {
     static void encode(Encoder&, const Ref<WebCore::ImageData>&);
-    static Optional<Ref<WebCore::ImageData>> decode(Decoder&) WARN_UNUSED_RETURN;
+    static Optional<Ref<WebCore::ImageData>> decode(Decoder&);
 };
 
 } // namespace IPC

_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to