Extended Color Cleanup: Move Color coder definitions to Color to allow for future...
[WebKit-https.git] / Source / WebKit / Shared / WebCoreArgumentCoders.h
1 /*
2  * Copyright (C) 2010-2020 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "ArgumentCoders.h"
29 #include <WebCore/AutoplayEvent.h>
30 #include <WebCore/ColorSpace.h>
31 #include <WebCore/DiagnosticLoggingClient.h>
32 #include <WebCore/FrameLoaderTypes.h>
33 #include <WebCore/ImageData.h>
34 #include <WebCore/IndexedDB.h>
35 #include <WebCore/InputMode.h>
36 #include <WebCore/MediaSelectionOption.h>
37 #include <WebCore/NetworkLoadMetrics.h>
38 #include <WebCore/NotificationDirection.h>
39 #include <WebCore/RealtimeMediaSource.h>
40 #include <WebCore/RenderingMode.h>
41 #include <WebCore/ScrollSnapOffsetsInfo.h>
42 #include <WebCore/SerializedPlatformDataCueValue.h>
43 #include <WebCore/ServiceWorkerTypes.h>
44 #include <WebCore/StoredCredentialsPolicy.h>
45 #include <WebCore/WorkerType.h>
46 #include <wtf/EnumTraits.h>
47
48 #if ENABLE(APPLE_PAY)
49 #include <WebCore/PaymentHeaders.h>
50 #endif
51
52 #if USE(CURL)
53 #include <WebCore/CurlProxySettings.h>
54 #endif
55
56 #if USE(APPLE_INTERNAL_SDK)
57 #include <WebKitAdditions/WebCoreArgumentCodersAdditions.h>
58 #endif
59
60 #if ENABLE(ENCRYPTED_MEDIA)
61 #include <WebCore/CDMInstance.h>
62 #include <WebCore/CDMInstanceSession.h>
63 #endif
64
65 #if PLATFORM(GTK)
66 #include "ArgumentCodersGtk.h"
67 #endif
68
69 #if PLATFORM(COCOA)
70 namespace WTF {
71 class MachSendRight;
72 }
73 #endif
74
75 namespace WebCore {
76
77 class AbsolutePositionConstraints;
78 class AffineTransform;
79 class AuthenticationChallenge;
80 class BlobPart;
81 class CertificateInfo;
82 class Color;
83 class Credential;
84 class CubicBezierTimingFunction;
85 class Cursor;
86 class DatabaseDetails;
87 class DragData;
88 class File;
89 class FilterOperation;
90 class FilterOperations;
91 class FloatPoint;
92 class FloatPoint3D;
93 class FloatRect;
94 class FloatRoundedRect;
95 class FloatSize;
96 class FixedPositionViewportConstraints;
97 class FontHandle;
98 class HTTPHeaderMap;
99 class ImageHandle;
100 class IntPoint;
101 class IntRect;
102 class IntSize;
103 class KeyframeValueList;
104 class LayoutSize;
105 class LayoutPoint;
106 class LinearTimingFunction;
107 class NativeImageHandle;
108 class Notification;
109 class PasteboardCustomData;
110 class PaymentInstallmentConfiguration;
111 class ProtectionSpace;
112 class Region;
113 class ResourceError;
114 class ResourceRequest;
115 class ResourceResponse;
116 class SecurityOrigin;
117 class SharedBuffer;
118 class SpringTimingFunction;
119 class StepsTimingFunction;
120 class StickyPositionViewportConstraints;
121 class TextCheckingRequestData;
122 class TransformationMatrix;
123 class UserStyleSheet;
124
125 struct AttributedString;
126 struct CacheQueryOptions;
127 struct CharacterRange;
128 struct CompositionUnderline;
129 struct DictationAlternative;
130 struct DictionaryPopupInfo;
131 struct EventTrackingRegions;
132 struct ExceptionDetails;
133 struct FontAttributes;
134 struct FileChooserSettings;
135 struct RawFile;
136 struct ShareData;
137 struct ShareDataWithParsedURL;
138 struct Length;
139 struct GrammarDetail;
140 struct MimeClassInfo;
141 struct PasteboardImage;
142 struct PasteboardURL;
143 struct PluginInfo;
144 struct PromisedAttachmentInfo;
145 struct RecentSearch;
146 struct ResourceLoadStatistics;
147 struct ScrollableAreaParameters;
148 struct TextCheckingResult;
149 struct TextIndicatorData;
150 struct TouchActionData;
151 struct VelocityData;
152 struct ViewportAttributes;
153 struct WindowFeatures;
154     
155 template<typename> class RectEdges;
156 using FloatBoxExtent = RectEdges<float>;
157
158 #if PLATFORM(COCOA)
159 struct KeypressCommand;
160 #endif
161
162 #if PLATFORM(IOS_FAMILY)
163 class FloatQuad;
164 class SelectionRect;
165 struct Highlight;
166 struct PasteboardImage;
167 struct PasteboardWebContent;
168 #endif
169
170 #if ENABLE(META_VIEWPORT)
171 struct ViewportArguments;
172 #endif
173
174 #if USE(SOUP)
175 struct SoupNetworkProxySettings;
176 #endif
177
178 #if USE(LIBWPE)
179 struct PasteboardWebContent;
180 #endif
181
182 #if ENABLE(CONTENT_FILTERING)
183 class ContentFilterUnblockHandler;
184 #endif
185
186 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
187 class MediaPlaybackTargetContext;
188 #endif
189
190 #if ENABLE(MEDIA_SESSION)
191 class MediaSessionMetadata;
192 #endif
193
194 #if ENABLE(MEDIA_STREAM)
195 struct MediaConstraints;
196 #endif
197
198 #if ENABLE(ATTACHMENT_ELEMENT)
199 struct SerializedAttachmentData;
200 #endif
201
202 #if ENABLE(INDEXED_DATABASE)
203 using IDBKeyPath = Variant<String, Vector<String>>;
204 #endif
205
206 namespace DOMCacheEngine {
207 struct CacheInfo;
208 struct Record;
209 }
210
211 } // namespace WebCore
212
213 namespace IPC {
214
215 template<> struct ArgumentCoder<WebCore::AffineTransform> {
216     static void encode(Encoder&, const WebCore::AffineTransform&);
217     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AffineTransform&);
218 };
219
220 template<> struct ArgumentCoder<WebCore::AttributedString> {
221     static void encode(Encoder&, const WebCore::AttributedString&);
222     static Optional<WebCore::AttributedString> decode(Decoder&);
223 };
224
225 template<> struct ArgumentCoder<WebCore::CacheQueryOptions> {
226     static void encode(Encoder&, const WebCore::CacheQueryOptions&);
227     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CacheQueryOptions&);
228 };
229
230 template<> struct ArgumentCoder<WebCore::CharacterRange> {
231     static void encode(Encoder&, const WebCore::CharacterRange&);
232     static Optional<WebCore::CharacterRange> decode(Decoder&);
233 };
234
235 template<> struct ArgumentCoder<WebCore::DOMCacheEngine::CacheInfo> {
236     static void encode(Encoder&, const WebCore::DOMCacheEngine::CacheInfo&);
237     static Optional<WebCore::DOMCacheEngine::CacheInfo> decode(Decoder&);
238 };
239
240 template<> struct ArgumentCoder<WebCore::DOMCacheEngine::Record> {
241     static void encode(Encoder&, const WebCore::DOMCacheEngine::Record&);
242     static Optional<WebCore::DOMCacheEngine::Record> decode(Decoder&);
243 };
244
245 template<> struct ArgumentCoder<WebCore::TouchActionData> {
246     static void encode(Encoder&, const WebCore::TouchActionData&);
247     static Optional<WebCore::TouchActionData> decode(Decoder&);
248 };
249
250 template<> struct ArgumentCoder<WebCore::EventTrackingRegions> {
251     static void encode(Encoder&, const WebCore::EventTrackingRegions&);
252     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::EventTrackingRegions&);
253 };
254
255 template<> struct ArgumentCoder<WebCore::TransformationMatrix> {
256     static void encode(Encoder&, const WebCore::TransformationMatrix&);
257     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::TransformationMatrix&);
258 };
259
260 template<> struct ArgumentCoder<WebCore::LinearTimingFunction> {
261     static void encode(Encoder&, const WebCore::LinearTimingFunction&);
262     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LinearTimingFunction&);
263 };
264
265 template<> struct ArgumentCoder<WebCore::CubicBezierTimingFunction> {
266     static void encode(Encoder&, const WebCore::CubicBezierTimingFunction&);
267     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CubicBezierTimingFunction&);
268 };
269
270 template<> struct ArgumentCoder<WebCore::StepsTimingFunction> {
271     static void encode(Encoder&, const WebCore::StepsTimingFunction&);
272     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::StepsTimingFunction&);
273 };
274
275 template<> struct ArgumentCoder<WebCore::SpringTimingFunction> {
276     static void encode(Encoder&, const WebCore::SpringTimingFunction&);
277     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::SpringTimingFunction&);
278 };
279
280 template<> struct ArgumentCoder<WebCore::CertificateInfo> {
281     static void encode(Encoder&, const WebCore::CertificateInfo&);
282     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::CertificateInfo&);
283 };
284
285 template<> struct ArgumentCoder<WebCore::FloatPoint> {
286     static void encode(Encoder&, const WebCore::FloatPoint&);
287     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatPoint&);
288     static Optional<WebCore::FloatPoint> decode(Decoder&);
289 };
290
291 template<> struct ArgumentCoder<WebCore::FloatPoint3D> {
292     static void encode(Encoder&, const WebCore::FloatPoint3D&);
293     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatPoint3D&);
294 };
295
296 template<> struct ArgumentCoder<WebCore::FloatRect> {
297     static void encode(Encoder&, const WebCore::FloatRect&);
298     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatRect&);
299     static Optional<WebCore::FloatRect> decode(Decoder&);
300 };
301     
302 template<> struct ArgumentCoder<WebCore::FloatBoxExtent> {
303     static void encode(Encoder&, const WebCore::FloatBoxExtent&);
304     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatBoxExtent&);
305 };
306
307 template<> struct ArgumentCoder<WebCore::FloatSize> {
308     static void encode(Encoder&, const WebCore::FloatSize&);
309     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatSize&);
310 };
311
312 template<> struct ArgumentCoder<WebCore::FloatRoundedRect> {
313     static void encode(Encoder&, const WebCore::FloatRoundedRect&);
314     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FloatRoundedRect&);
315 };
316
317 #if PLATFORM(IOS_FAMILY)
318 template<> struct ArgumentCoder<WebCore::FloatQuad> {
319     static void encode(Encoder&, const WebCore::FloatQuad&);
320     static Optional<WebCore::FloatQuad> decode(Decoder&);
321 };
322 #endif // PLATFORM(IOS_FAMILY)
323
324 #if ENABLE(META_VIEWPORT)
325 template<> struct ArgumentCoder<WebCore::ViewportArguments> {
326     static void encode(Encoder&, const WebCore::ViewportArguments&);
327     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ViewportArguments&);
328     static Optional<WebCore::ViewportArguments> decode(Decoder&);
329 };
330
331 #endif
332
333 template<> struct ArgumentCoder<WebCore::ViewportAttributes> {
334     static void encode(Encoder&, const WebCore::ViewportAttributes&);
335     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ViewportAttributes&);
336 };
337
338 template<> struct ArgumentCoder<WebCore::IntPoint> {
339     static void encode(Encoder&, const WebCore::IntPoint&);
340     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntPoint&);
341     static Optional<WebCore::IntPoint> decode(Decoder&);
342 };
343
344 template<> struct ArgumentCoder<WebCore::IntRect> {
345     static void encode(Encoder&, const WebCore::IntRect&);
346     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntRect&);
347     static Optional<WebCore::IntRect> decode(Decoder&);
348 };
349
350 template<> struct ArgumentCoder<WebCore::IntSize> {
351     static void encode(Encoder&, const WebCore::IntSize&);
352     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IntSize&);
353     static Optional<WebCore::IntSize> decode(Decoder&);
354 };
355
356 template<> struct ArgumentCoder<WebCore::LayoutSize> {
357     static void encode(Encoder&, const WebCore::LayoutSize&);
358     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LayoutSize&);
359 };
360
361 template<> struct ArgumentCoder<WebCore::LayoutPoint> {
362     static void encode(Encoder&, const WebCore::LayoutPoint&);
363     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::LayoutPoint&);
364 };
365
366 template<> struct ArgumentCoder<WebCore::Length> {
367     static void encode(Encoder&, const WebCore::Length&);
368     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Length&);
369 };
370
371 template<> struct ArgumentCoder<WebCore::VelocityData> {
372     static void encode(Encoder&, const WebCore::VelocityData&);
373     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::VelocityData&);
374 };
375
376 template<> struct ArgumentCoder<WebCore::MimeClassInfo> {
377     static void encode(Encoder&, const WebCore::MimeClassInfo&);
378     static Optional<WebCore::MimeClassInfo> decode(Decoder&);
379 };
380
381 template<> struct ArgumentCoder<WebCore::PluginInfo> {
382     static void encode(Encoder&, const WebCore::PluginInfo&);
383     static Optional<WebCore::PluginInfo> decode(Decoder&);
384 };
385
386 template<> struct ArgumentCoder<WebCore::AuthenticationChallenge> {
387     static void encode(Encoder&, const WebCore::AuthenticationChallenge&);
388     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AuthenticationChallenge&);
389 };
390
391 template<> struct ArgumentCoder<WebCore::ProtectionSpace> {
392     static void encode(Encoder&, const WebCore::ProtectionSpace&);
393     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ProtectionSpace&);
394     static void encodePlatformData(Encoder&, const WebCore::ProtectionSpace&);
395     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ProtectionSpace&);
396 };
397
398 template<> struct ArgumentCoder<WebCore::Credential> {
399     static void encode(Encoder&, const WebCore::Credential&);
400     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Credential&);
401     static void encodePlatformData(Encoder&, const WebCore::Credential&);
402     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::Credential&);
403 };
404
405 template<> struct ArgumentCoder<WebCore::Cursor> {
406     static void encode(Encoder&, const WebCore::Cursor&);
407     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Cursor&);
408 };
409
410 template<> struct ArgumentCoder<WebCore::FontHandle> {
411     static void encode(Encoder&, const WebCore::FontHandle&);
412     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FontHandle&);
413     static void encodePlatformData(Encoder&, const WebCore::FontHandle&);
414     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::FontHandle&);
415 };
416
417 template<> struct ArgumentCoder<WebCore::ImageHandle> {
418     static void encode(Encoder&, const WebCore::ImageHandle&);
419     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ImageHandle&);
420 };
421
422 template<> struct ArgumentCoder<WebCore::NativeImageHandle> {
423     static void encode(Encoder&, const WebCore::NativeImageHandle&);
424     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::NativeImageHandle&);
425 };
426
427 template<> struct ArgumentCoder<WebCore::ResourceRequest> {
428     static void encode(Encoder&, const WebCore::ResourceRequest&);
429     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ResourceRequest&);
430     static void encodePlatformData(Encoder&, const WebCore::ResourceRequest&);
431     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ResourceRequest&);
432 };
433
434 template<> struct ArgumentCoder<WebCore::ResourceError> {
435     static void encode(Encoder&, const WebCore::ResourceError&);
436     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ResourceError&);
437     static void encodePlatformData(Encoder&, const WebCore::ResourceError&);
438     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::ResourceError&);
439 };
440
441 template<> struct ArgumentCoder<WebCore::WindowFeatures> {
442     static void encode(Encoder&, const WebCore::WindowFeatures&);
443     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::WindowFeatures&);
444 };
445
446 #if ENABLE(DRAG_SUPPORT)
447 template<> struct ArgumentCoder<WebCore::DragData> {
448     static void encode(Encoder&, const WebCore::DragData&);
449     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DragData&);
450 };
451 #endif
452
453 #if PLATFORM(COCOA)
454 template<> struct ArgumentCoder<WTF::MachSendRight> {
455     static void encode(Encoder&, const WTF::MachSendRight&);
456     static void encode(Encoder&, WTF::MachSendRight&&);
457     static WARN_UNUSED_RETURN bool decode(Decoder&, WTF::MachSendRight&);
458 };
459
460 template<> struct ArgumentCoder<WebCore::KeypressCommand> {
461     static void encode(Encoder&, const WebCore::KeypressCommand&);
462     static Optional<WebCore::KeypressCommand> decode(Decoder&);
463 };
464
465 template<> struct ArgumentCoder<CGPoint> {
466     static void encode(Encoder&, CGPoint);
467     static Optional<CGPoint> decode(Decoder&);
468 };
469
470 template<> struct ArgumentCoder<CGSize> {
471     static void encode(Encoder&, CGSize);
472     static Optional<CGSize> decode(Decoder&);
473 };
474
475 template<> struct ArgumentCoder<CGRect> {
476     static void encode(Encoder&, CGRect);
477     static Optional<CGRect> decode(Decoder&);
478 };
479
480 template<> struct ArgumentCoder<CGAffineTransform> {
481     static void encode(Encoder&, CGAffineTransform);
482     static Optional<CGAffineTransform> decode(Decoder&);
483 };
484 #endif
485
486 #if PLATFORM(IOS_FAMILY)
487 template<> struct ArgumentCoder<WebCore::SelectionRect> {
488     static void encode(Encoder&, const WebCore::SelectionRect&);
489     static Optional<WebCore::SelectionRect> decode(Decoder&);
490 };
491
492 template<> struct ArgumentCoder<WebCore::Highlight> {
493     static void encode(Encoder&, const WebCore::Highlight&);
494     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::Highlight&);
495 };
496
497 template<> struct ArgumentCoder<WebCore::PasteboardWebContent> {
498     static void encode(Encoder&, const WebCore::PasteboardWebContent&);
499     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardWebContent&);
500 };
501
502 template<> struct ArgumentCoder<WebCore::PasteboardImage> {
503     static void encode(Encoder&, const WebCore::PasteboardImage&);
504     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardImage&);
505 };
506 #endif
507
508 template<> struct ArgumentCoder<WebCore::PasteboardCustomData> {
509     static void encode(Encoder&, const WebCore::PasteboardCustomData&);
510     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardCustomData&);
511 };
512
513 template<> struct ArgumentCoder<WebCore::PasteboardURL> {
514     static void encode(Encoder&, const WebCore::PasteboardURL&);
515     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardURL&);
516 };
517
518 #if USE(SOUP)
519 template<> struct ArgumentCoder<WebCore::SoupNetworkProxySettings> {
520     static void encode(Encoder&, const WebCore::SoupNetworkProxySettings&);
521     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::SoupNetworkProxySettings&);
522 };
523 #endif
524
525 #if USE(LIBWPE)
526 template<> struct ArgumentCoder<WebCore::PasteboardWebContent> {
527     static void encode(Encoder&, const WebCore::PasteboardWebContent&);
528     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PasteboardWebContent&);
529 };
530 #endif
531
532 #if USE(CURL)
533 template<> struct ArgumentCoder<WebCore::CurlProxySettings> {
534     static void encode(Encoder&, const WebCore::CurlProxySettings&);
535     static Optional<WebCore::CurlProxySettings> decode(Decoder&);
536 };
537 #endif
538
539 template<> struct ArgumentCoder<WebCore::CompositionUnderline> {
540     static void encode(Encoder&, const WebCore::CompositionUnderline&);
541     static Optional<WebCore::CompositionUnderline> decode(Decoder&);
542 };
543
544 template<> struct ArgumentCoder<WebCore::DatabaseDetails> {
545     static void encode(Encoder&, const WebCore::DatabaseDetails&);
546     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DatabaseDetails&);
547 };
548
549 template<> struct ArgumentCoder<WebCore::DictationAlternative> {
550     static void encode(Encoder&, const WebCore::DictationAlternative&);
551     static Optional<WebCore::DictationAlternative> decode(Decoder&);
552 };
553
554 template<> struct ArgumentCoder<WebCore::FileChooserSettings> {
555     static void encode(Encoder&, const WebCore::FileChooserSettings&);
556     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FileChooserSettings&);
557 };
558     
559 template<> struct ArgumentCoder<WebCore::RawFile> {
560     static void encode(Encoder&, const WebCore::RawFile&);
561     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::RawFile&);
562 };
563
564 template<> struct ArgumentCoder<WebCore::ShareData> {
565     static void encode(Encoder&, const WebCore::ShareData&);
566     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ShareData&);
567 };
568     
569 template<> struct ArgumentCoder<WebCore::ShareDataWithParsedURL> {
570     static void encode(Encoder&, const WebCore::ShareDataWithParsedURL&);
571     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ShareDataWithParsedURL&);
572 };
573
574 template<> struct ArgumentCoder<WebCore::GrammarDetail> {
575     static void encode(Encoder&, const WebCore::GrammarDetail&);
576     static Optional<WebCore::GrammarDetail> decode(Decoder&);
577 };
578
579 template<> struct ArgumentCoder<WebCore::TextCheckingRequestData> {
580     static void encode(Encoder&, const WebCore::TextCheckingRequestData&);
581     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::TextCheckingRequestData&);
582 };
583
584 template<> struct ArgumentCoder<WebCore::TextCheckingResult> {
585     static void encode(Encoder&, const WebCore::TextCheckingResult&);
586     static Optional<WebCore::TextCheckingResult> decode(Decoder&);
587 };
588
589 template<> struct ArgumentCoder<WebCore::UserStyleSheet> {
590     static void encode(Encoder&, const WebCore::UserStyleSheet&);
591     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::UserStyleSheet&);
592 };
593
594 template<> struct ArgumentCoder<WebCore::ScrollableAreaParameters> {
595     static void encode(Encoder&, const WebCore::ScrollableAreaParameters&);
596     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ScrollableAreaParameters&);
597 };
598
599 template<> struct ArgumentCoder<WebCore::FixedPositionViewportConstraints> {
600     static void encode(Encoder&, const WebCore::FixedPositionViewportConstraints&);
601     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FixedPositionViewportConstraints&);
602 };
603
604 template<> struct ArgumentCoder<WebCore::StickyPositionViewportConstraints> {
605     static void encode(Encoder&, const WebCore::StickyPositionViewportConstraints&);
606     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::StickyPositionViewportConstraints&);
607 };
608
609 template<> struct ArgumentCoder<WebCore::AbsolutePositionConstraints> {
610     static void encode(Encoder&, const WebCore::AbsolutePositionConstraints&);
611     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::AbsolutePositionConstraints&);
612 };
613
614 #if !USE(COORDINATED_GRAPHICS)
615 template<> struct ArgumentCoder<WebCore::FilterOperations> {
616     static void encode(Encoder&, const WebCore::FilterOperations&);
617     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::FilterOperations&);
618 };
619     
620 template<> struct ArgumentCoder<WebCore::FilterOperation> {
621     static void encode(Encoder&, const WebCore::FilterOperation&);
622 };
623 WARN_UNUSED_RETURN bool decodeFilterOperation(Decoder&, RefPtr<WebCore::FilterOperation>&);
624 #endif
625
626 template<> struct ArgumentCoder<WebCore::BlobPart> {
627     static void encode(Encoder&, const WebCore::BlobPart&);
628     static Optional<WebCore::BlobPart> decode(Decoder&);
629 };
630
631 #if ENABLE(CONTENT_FILTERING)
632 template<> struct ArgumentCoder<WebCore::ContentFilterUnblockHandler> {
633     static void encode(Encoder&, const WebCore::ContentFilterUnblockHandler&);
634     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ContentFilterUnblockHandler&);
635 };
636 #endif
637
638 #if ENABLE(MEDIA_SESSION)
639 template<> struct ArgumentCoder<WebCore::MediaSessionMetadata> {
640     static void encode(Encoder&, const WebCore::MediaSessionMetadata&);
641     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaSessionMetadata&);
642 };
643 #endif
644
645 template<> struct ArgumentCoder<WebCore::TextIndicatorData> {
646     static void encode(Encoder&, const WebCore::TextIndicatorData&);
647     static Optional<WebCore::TextIndicatorData> decode(Decoder&);
648 };
649
650 template<> struct ArgumentCoder<WebCore::DictionaryPopupInfo> {
651     static void encode(Encoder&, const WebCore::DictionaryPopupInfo&);
652     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::DictionaryPopupInfo&);
653     static void encodePlatformData(Encoder&, const WebCore::DictionaryPopupInfo&);
654     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::DictionaryPopupInfo&);
655 };
656
657 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
658 template<> struct ArgumentCoder<WebCore::MediaPlaybackTargetContext> {
659     static void encode(Encoder&, const WebCore::MediaPlaybackTargetContext&);
660     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaPlaybackTargetContext&);
661     static void encodePlatformData(Encoder&, const WebCore::MediaPlaybackTargetContext&);
662     static WARN_UNUSED_RETURN bool decodePlatformData(Decoder&, WebCore::MediaPlaybackTargetContext&);
663 };
664 #endif
665
666 template<> struct ArgumentCoder<WebCore::RecentSearch> {
667     static void encode(Encoder&, const WebCore::RecentSearch&);
668     static Optional<WebCore::RecentSearch> decode(Decoder&);
669 };
670
671 template<> struct ArgumentCoder<WebCore::ExceptionDetails> {
672     static void encode(Encoder&, const WebCore::ExceptionDetails&);
673     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ExceptionDetails&);
674 };
675
676 template<> struct ArgumentCoder<WebCore::ResourceLoadStatistics> {
677     static void encode(Encoder&, const WebCore::ResourceLoadStatistics&);
678     static Optional<WebCore::ResourceLoadStatistics> decode(Decoder&);
679 };
680
681 #if ENABLE(APPLE_PAY)
682
683 template<> struct ArgumentCoder<WebCore::Payment> {
684     static void encode(Encoder&, const WebCore::Payment&);
685     static Optional<WebCore::Payment> decode(Decoder&);
686 };
687
688 template<> struct ArgumentCoder<WebCore::PaymentAuthorizationResult> {
689     static void encode(Encoder&, const WebCore::PaymentAuthorizationResult&);
690     static Optional<WebCore::PaymentAuthorizationResult> decode(Decoder&);
691 };
692
693 template<> struct ArgumentCoder<WebCore::PaymentContact> {
694     static void encode(Encoder&, const WebCore::PaymentContact&);
695     static Optional<WebCore::PaymentContact> decode(Decoder&);
696 };
697
698 template<> struct ArgumentCoder<WebCore::PaymentError> {
699     static void encode(Encoder&, const WebCore::PaymentError&);
700     static Optional<WebCore::PaymentError> decode(Decoder&);
701 };
702
703 template<> struct ArgumentCoder<WebCore::PaymentMerchantSession> {
704     static void encode(Encoder&, const WebCore::PaymentMerchantSession&);
705     static Optional<WebCore::PaymentMerchantSession> decode(Decoder&);
706 };
707
708 template<> struct ArgumentCoder<WebCore::PaymentMethod> {
709     static void encode(Encoder&, const WebCore::PaymentMethod&);
710     static Optional<WebCore::PaymentMethod> decode(Decoder&);
711 };
712
713 template<> struct ArgumentCoder<WebCore::PaymentMethodUpdate> {
714     static void encode(Encoder&, const WebCore::PaymentMethodUpdate&);
715     static Optional<WebCore::PaymentMethodUpdate> decode(Decoder&);
716 };
717
718 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest> {
719     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest&);
720     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest&);
721 };
722
723 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::ContactFields> {
724     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::ContactFields&);
725     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::ContactFields&);
726 };
727
728 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::LineItem> {
729     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::LineItem&);
730     static Optional<WebCore::ApplePaySessionPaymentRequest::LineItem> decode(Decoder&);
731 };
732
733 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities> {
734     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities&);
735     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ApplePaySessionPaymentRequest::MerchantCapabilities&);
736 };
737
738 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::ShippingMethod> {
739     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::ShippingMethod&);
740     static Optional<WebCore::ApplePaySessionPaymentRequest::ShippingMethod> decode(Decoder&);
741 };
742
743 template<> struct ArgumentCoder<WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems> {
744     static void encode(Encoder&, const WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems&);
745     static Optional<WebCore::ApplePaySessionPaymentRequest::TotalAndLineItems> decode(Decoder&);
746 };
747
748 template<> struct ArgumentCoder<WebCore::ShippingContactUpdate> {
749     static void encode(Encoder&, const WebCore::ShippingContactUpdate&);
750     static Optional<WebCore::ShippingContactUpdate> decode(Decoder&);
751 };
752
753 template<> struct ArgumentCoder<WebCore::ShippingMethodUpdate> {
754     static void encode(Encoder&, const WebCore::ShippingMethodUpdate&);
755     static Optional<WebCore::ShippingMethodUpdate> decode(Decoder&);
756 };
757
758 template<> struct ArgumentCoder<WebCore::PaymentSessionError> {
759     static void encode(Encoder&, const WebCore::PaymentSessionError&);
760     static Optional<WebCore::PaymentSessionError> decode(Decoder&);
761 };
762
763 #endif
764
765 #if ENABLE(MEDIA_STREAM)
766 template<> struct ArgumentCoder<WebCore::MediaConstraints> {
767     static void encode(Encoder&, const WebCore::MediaConstraints&);
768     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::MediaConstraints&);
769 };
770 #endif
771
772 #if ENABLE(INDEXED_DATABASE)
773
774 template<> struct ArgumentCoder<WebCore::IDBKeyPath> {
775     static void encode(Encoder&, const WebCore::IDBKeyPath&);
776     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::IDBKeyPath&);
777 };
778
779 #endif
780
781 #if ENABLE(SERVICE_WORKER)
782
783 template<> struct ArgumentCoder<WebCore::ServiceWorkerOrClientData> {
784     static void encode(Encoder&, const WebCore::ServiceWorkerOrClientData&);
785     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ServiceWorkerOrClientData&);
786 };
787
788 template<> struct ArgumentCoder<WebCore::ServiceWorkerOrClientIdentifier> {
789     static void encode(Encoder&, const WebCore::ServiceWorkerOrClientIdentifier&);
790     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ServiceWorkerOrClientIdentifier&);
791 };
792
793 #endif
794
795 #if ENABLE(CSS_SCROLL_SNAP)
796
797 template<> struct ArgumentCoder<WebCore::ScrollOffsetRange<float>> {
798     static void encode(Encoder&, const WebCore::ScrollOffsetRange<float>&);
799     static Optional<WebCore::ScrollOffsetRange<float>> decode(Decoder&);
800 };
801
802 #endif
803
804 template<> struct ArgumentCoder<WebCore::MediaSelectionOption> {
805     static void encode(Encoder&, const WebCore::MediaSelectionOption&);
806     static Optional<WebCore::MediaSelectionOption> decode(Decoder&);
807 };
808
809 template<> struct ArgumentCoder<WebCore::PromisedAttachmentInfo> {
810     static void encode(Encoder&, const WebCore::PromisedAttachmentInfo&);
811     static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PromisedAttachmentInfo&);
812 };
813
814 template<> struct ArgumentCoder<Vector<RefPtr<WebCore::SecurityOrigin>>> {
815     static void encode(Encoder&, const Vector<RefPtr<WebCore::SecurityOrigin>>&);
816     static WARN_UNUSED_RETURN bool decode(Decoder&, Vector<RefPtr<WebCore::SecurityOrigin>>&);
817 };
818
819 template<> struct ArgumentCoder<WebCore::FontAttributes> {
820     static void encode(Encoder&, const WebCore::FontAttributes&);
821     static Optional<WebCore::FontAttributes> decode(Decoder&);
822     static void encodePlatformData(Encoder&, const WebCore::FontAttributes&);
823     static Optional<WebCore::FontAttributes> decodePlatformData(Decoder&, WebCore::FontAttributes&);
824 };
825
826 #if ENABLE(ATTACHMENT_ELEMENT)
827
828 template<> struct ArgumentCoder<WebCore::SerializedAttachmentData> {
829     static void encode(Encoder&, const WebCore::SerializedAttachmentData&);
830     static Optional<WebCore::SerializedAttachmentData> decode(Decoder&);
831 };
832
833 #endif // ENABLE(ATTACHMENT_ELEMENT)
834
835 #if ENABLE(VIDEO)
836 template<> struct ArgumentCoder<WebCore::SerializedPlatformDataCueValue> {
837     static void encode(Encoder&, const WebCore::SerializedPlatformDataCueValue&);
838     static Optional<WebCore::SerializedPlatformDataCueValue> decode(Decoder&);
839     static void encodePlatformData(Encoder&, const WebCore::SerializedPlatformDataCueValue&);
840     static Optional<WebCore::SerializedPlatformDataCueValue> decodePlatformData(Decoder&, WebCore::SerializedPlatformDataCueValue::PlatformType);
841 };
842 #endif
843
844 template<> struct ArgumentCoder<RefPtr<WebCore::SharedBuffer>> {
845     static void encode(Encoder&, const RefPtr<WebCore::SharedBuffer>&);
846     static Optional<RefPtr<WebCore::SharedBuffer>> decode(Decoder&);
847 };
848
849 template<> struct ArgumentCoder<Ref<WebCore::SharedBuffer>> {
850     static void encode(Encoder&, const Ref<WebCore::SharedBuffer>&);
851     static Optional<Ref<WebCore::SharedBuffer>> decode(Decoder&);
852 };
853
854 #if ENABLE(ENCRYPTED_MEDIA)
855 template<> struct ArgumentCoder<WebCore::CDMInstanceSession::Message> {
856     static void encode(Encoder&, const WebCore::CDMInstanceSession::Message&);
857     static Optional<WebCore::CDMInstanceSession::Message> decode(Decoder&);
858 };
859
860 template<> struct ArgumentCoder<WebCore::CDMInstanceSession::KeyStatusVector> {
861     static void encode(Encoder&, const WebCore::CDMInstanceSession::KeyStatusVector&);
862     static Optional<WebCore::CDMInstanceSession::KeyStatusVector> decode(Decoder&);
863 };
864 #endif
865
866 template<> struct ArgumentCoder<RefPtr<WebCore::ImageData>> {
867     static void encode(Encoder&, const RefPtr<WebCore::ImageData>&);
868     static Optional<RefPtr<WebCore::ImageData>> decode(Decoder&);
869 };
870
871 template<> struct ArgumentCoder<Ref<WebCore::ImageData>> {
872     static void encode(Encoder&, const Ref<WebCore::ImageData>&);
873     static Optional<Ref<WebCore::ImageData>> decode(Decoder&);
874 };
875
876 #if HAVE(PASSKIT_INSTALLMENTS)
877 template<> struct ArgumentCoder<WebCore::PaymentInstallmentConfiguration> {
878     static void encode(Encoder&, const WebCore::PaymentInstallmentConfiguration&);
879     static Optional<WebCore::PaymentInstallmentConfiguration> decode(Decoder&);
880 };
881 #endif
882
883 } // namespace IPC
884
885 namespace WTF {
886
887 template<> struct EnumTraits<WebCore::ColorSpace> {
888     using values = EnumValues<
889     WebCore::ColorSpace,
890     WebCore::ColorSpace::SRGB,
891     WebCore::ColorSpace::LinearRGB,
892     WebCore::ColorSpace::DisplayP3
893     >;
894 };
895
896 template<> struct EnumTraits<WebCore::RenderingMode> {
897     using values = EnumValues<
898     WebCore::RenderingMode,
899     WebCore::RenderingMode::Accelerated,
900     WebCore::RenderingMode::Unaccelerated,
901     WebCore::RenderingMode::DisplayListAccelerated,
902     WebCore::RenderingMode::DisplayListUnaccelerated,
903     WebCore::RenderingMode::RemoteAccelerated,
904     WebCore::RenderingMode::RemoteUnaccelerated
905     >;
906 };
907
908 template<> struct EnumTraits<WebCore::AutoplayEvent> {
909     using values = EnumValues<
910         WebCore::AutoplayEvent,
911         WebCore::AutoplayEvent::DidPreventMediaFromPlaying,
912         WebCore::AutoplayEvent::DidPlayMediaWithUserGesture,
913         WebCore::AutoplayEvent::DidAutoplayMediaPastThresholdWithoutUserInterference,
914         WebCore::AutoplayEvent::UserDidInterfereWithPlayback
915     >;
916 };
917
918 template<> struct EnumTraits<WebCore::InputMode> {
919     using values = EnumValues<
920         WebCore::InputMode,
921         WebCore::InputMode::Unspecified,
922         WebCore::InputMode::None,
923         WebCore::InputMode::Text,
924         WebCore::InputMode::Telephone,
925         WebCore::InputMode::Url,
926         WebCore::InputMode::Email,
927         WebCore::InputMode::Numeric,
928         WebCore::InputMode::Decimal,
929         WebCore::InputMode::Search
930     >;
931 };
932
933 template<> struct EnumTraits<WebCore::NetworkLoadPriority> {
934     using values = EnumValues<
935         WebCore::NetworkLoadPriority,
936         WebCore::NetworkLoadPriority::Low,
937         WebCore::NetworkLoadPriority::Medium,
938         WebCore::NetworkLoadPriority::High,
939         WebCore::NetworkLoadPriority::Unknown
940     >;
941 };
942
943 template<> struct EnumTraits<WebCore::NotificationDirection> {
944     using values = EnumValues<
945         WebCore::NotificationDirection,
946         WebCore::NotificationDirection::Auto,
947         WebCore::NotificationDirection::Ltr,
948         WebCore::NotificationDirection::Rtl
949     >;
950 };
951
952 #if ENABLE(INDEXED_DATABASE)
953 template<> struct EnumTraits<WebCore::IndexedDB::GetAllType> {
954     using values = EnumValues<
955         WebCore::IndexedDB::GetAllType,
956         WebCore::IndexedDB::GetAllType::Keys,
957         WebCore::IndexedDB::GetAllType::Values
958     >;
959 };
960 #endif
961
962 #if ENABLE(MEDIA_STREAM)
963 template<> struct EnumTraits<WebCore::RealtimeMediaSource::Type> {
964     using values = EnumValues<
965         WebCore::RealtimeMediaSource::Type,
966         WebCore::RealtimeMediaSource::Type::None,
967         WebCore::RealtimeMediaSource::Type::Audio,
968         WebCore::RealtimeMediaSource::Type::Video
969     >;
970 };
971 #endif
972
973 template<> struct EnumTraits<WebCore::MediaSelectionOption::Type> {
974     using values = EnumValues<
975         WebCore::MediaSelectionOption::Type,
976         WebCore::MediaSelectionOption::Type::Regular,
977         WebCore::MediaSelectionOption::Type::LegibleOff,
978         WebCore::MediaSelectionOption::Type::LegibleAuto
979     >;
980 };
981
982 template <> struct EnumTraits<WebCore::WorkerType> {
983     using values = EnumValues<
984         WebCore::WorkerType,
985         WebCore::WorkerType::Classic,
986         WebCore::WorkerType::Module
987     >;
988 };
989
990 template<> struct EnumTraits<WebCore::StoredCredentialsPolicy> {
991     using values = EnumValues<
992         WebCore::StoredCredentialsPolicy,
993         WebCore::StoredCredentialsPolicy::DoNotUse,
994         WebCore::StoredCredentialsPolicy::Use,
995         WebCore::StoredCredentialsPolicy::EphemeralStateless
996     >;
997 };
998
999 #if USE(CURL)
1000 template <> struct EnumTraits<WebCore::CurlProxySettings::Mode> {
1001     using values = EnumValues<
1002         WebCore::CurlProxySettings::Mode,
1003         WebCore::CurlProxySettings::Mode::Default,
1004         WebCore::CurlProxySettings::Mode::NoProxy,
1005         WebCore::CurlProxySettings::Mode::Custom
1006     >;
1007 };
1008 #endif
1009
1010 template<> struct EnumTraits<WTFLogChannelState> {
1011     using values = EnumValues<
1012     WTFLogChannelState,
1013     WTFLogChannelState::Off,
1014     WTFLogChannelState::On,
1015     WTFLogChannelState::OnWithAccumulation
1016     >;
1017 };
1018
1019 #undef Always
1020 template<> struct EnumTraits<WTFLogLevel> {
1021     using values = EnumValues<
1022     WTFLogLevel,
1023     WTFLogLevel::Always,
1024     WTFLogLevel::Error,
1025     WTFLogLevel::Warning,
1026     WTFLogLevel::Info,
1027     WTFLogLevel::Debug
1028     >;
1029 };
1030
1031 #if ENABLE(ENCRYPTED_MEDIA)
1032 template <> struct EnumTraits<WebCore::CDMInstanceSession::SessionLoadFailure> {
1033     using values = EnumValues <
1034     WebCore::CDMInstanceSession::SessionLoadFailure,
1035     WebCore::CDMInstanceSession::SessionLoadFailure::None,
1036     WebCore::CDMInstanceSession::SessionLoadFailure::NoSessionData,
1037     WebCore::CDMInstanceSession::SessionLoadFailure::MismatchedSessionType,
1038     WebCore::CDMInstanceSession::SessionLoadFailure::QuotaExceeded,
1039     WebCore::CDMInstanceSession::SessionLoadFailure::Other
1040     >;
1041 };
1042
1043 template <> struct EnumTraits<WebCore::CDMInstance::HDCPStatus> {
1044     using values = EnumValues <
1045     WebCore::CDMInstance::HDCPStatus,
1046     WebCore::CDMInstance::HDCPStatus::Unknown,
1047     WebCore::CDMInstance::HDCPStatus::Valid,
1048     WebCore::CDMInstance::HDCPStatus::OutputRestricted,
1049     WebCore::CDMInstance::HDCPStatus::OutputDownscaled
1050     >;
1051 };
1052
1053 #endif
1054
1055 } // namespace WTF