d6e58f3f5e156c1c381f5c19116c8d1879128c1c
[WebKit-https.git] / Source / WebKit / Shared / WebCoreArgumentCoders.cpp
1 /*
2  * Copyright (C) 2011-2017 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 #include "config.h"
27 #include "WebCoreArgumentCoders.h"
28
29 #include "DataReference.h"
30 #include "ShareableBitmap.h"
31 #include <WebCore/AuthenticationChallenge.h>
32 #include <WebCore/BlobPart.h>
33 #include <WebCore/CacheQueryOptions.h>
34 #include <WebCore/CertificateInfo.h>
35 #include <WebCore/CompositionUnderline.h>
36 #include <WebCore/Credential.h>
37 #include <WebCore/Cursor.h>
38 #include <WebCore/DatabaseDetails.h>
39 #include <WebCore/DictationAlternative.h>
40 #include <WebCore/DictionaryPopupInfo.h>
41 #include <WebCore/DragData.h>
42 #include <WebCore/EventTrackingRegions.h>
43 #include <WebCore/FetchOptions.h>
44 #include <WebCore/FileChooser.h>
45 #include <WebCore/FilterOperation.h>
46 #include <WebCore/FilterOperations.h>
47 #include <WebCore/GraphicsContext.h>
48 #include <WebCore/GraphicsLayer.h>
49 #include <WebCore/IDBGetResult.h>
50 #include <WebCore/Image.h>
51 #include <WebCore/JSDOMExceptionHandling.h>
52 #include <WebCore/Length.h>
53 #include <WebCore/LengthBox.h>
54 #include <WebCore/MediaSelectionOption.h>
55 #include <WebCore/Path.h>
56 #include <WebCore/PluginData.h>
57 #include <WebCore/ProtectionSpace.h>
58 #include <WebCore/Region.h>
59 #include <WebCore/ResourceError.h>
60 #include <WebCore/ResourceLoadStatistics.h>
61 #include <WebCore/ResourceRequest.h>
62 #include <WebCore/ResourceResponse.h>
63 #include <WebCore/ScrollingConstraints.h>
64 #include <WebCore/ScrollingCoordinator.h>
65 #include <WebCore/SearchPopupMenu.h>
66 #include <WebCore/TextCheckerClient.h>
67 #include <WebCore/TextIndicator.h>
68 #include <WebCore/TimingFunction.h>
69 #include <WebCore/TransformationMatrix.h>
70 #include <WebCore/URL.h>
71 #include <WebCore/UserStyleSheet.h>
72 #include <WebCore/ViewportArguments.h>
73 #include <WebCore/WindowFeatures.h>
74 #include <pal/SessionID.h>
75 #include <wtf/MonotonicTime.h>
76 #include <wtf/Seconds.h>
77 #include <wtf/text/CString.h>
78 #include <wtf/text/StringHash.h>
79
80 #if PLATFORM(COCOA)
81 #include "ArgumentCodersCF.h"
82 #include "ArgumentCodersMac.h"
83 #endif
84
85 #if PLATFORM(IOS)
86 #include <WebCore/FloatQuad.h>
87 #include <WebCore/InspectorOverlay.h>
88 #include <WebCore/SelectionRect.h>
89 #include <WebCore/SharedBuffer.h>
90 #endif // PLATFORM(IOS)
91
92 #if PLATFORM(IOS) || PLATFORM(WPE)
93 #include <WebCore/Pasteboard.h>
94 #endif
95
96 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
97 #include <WebCore/MediaPlaybackTargetContext.h>
98 #endif
99
100 #if ENABLE(MEDIA_SESSION)
101 #include <WebCore/MediaSessionMetadata.h>
102 #endif
103
104 #if ENABLE(MEDIA_STREAM)
105 #include <WebCore/CaptureDevice.h>
106 #include <WebCore/MediaConstraints.h>
107 #endif
108
109 using namespace WebCore;
110 using namespace WebKit;
111
112 namespace IPC {
113
114 void ArgumentCoder<MonotonicTime>::encode(Encoder& encoder, const MonotonicTime& time)
115 {
116     encoder << time.secondsSinceEpoch().value();
117 }
118
119 bool ArgumentCoder<MonotonicTime>::decode(Decoder& decoder, MonotonicTime& time)
120 {
121     double value;
122     if (!decoder.decode(value))
123         return false;
124
125     time = MonotonicTime::fromRawSeconds(value);
126     return true;
127 }
128
129 void ArgumentCoder<Seconds>::encode(Encoder& encoder, const Seconds& seconds)
130 {
131     encoder << seconds.value();
132 }
133
134 bool ArgumentCoder<Seconds>::decode(Decoder& decoder, Seconds& seconds)
135 {
136     double value;
137     if (!decoder.decode(value))
138         return false;
139
140     seconds = Seconds(value);
141     return true;
142 }
143
144 void ArgumentCoder<AffineTransform>::encode(Encoder& encoder, const AffineTransform& affineTransform)
145 {
146     SimpleArgumentCoder<AffineTransform>::encode(encoder, affineTransform);
147 }
148
149 bool ArgumentCoder<AffineTransform>::decode(Decoder& decoder, AffineTransform& affineTransform)
150 {
151     return SimpleArgumentCoder<AffineTransform>::decode(decoder, affineTransform);
152 }
153
154 void ArgumentCoder<CacheQueryOptions>::encode(Encoder& encoder, const CacheQueryOptions& options)
155 {
156     encoder << options.ignoreSearch;
157     encoder << options.ignoreMethod;
158     encoder << options.ignoreVary;
159     encoder << options.cacheName;
160 }
161
162 bool ArgumentCoder<CacheQueryOptions>::decode(Decoder& decoder, CacheQueryOptions& options)
163 {
164     bool ignoreSearch;
165     if (!decoder.decode(ignoreSearch))
166         return false;
167     bool ignoreMethod;
168     if (!decoder.decode(ignoreMethod))
169         return false;
170     bool ignoreVary;
171     if (!decoder.decode(ignoreVary))
172         return false;
173     String cacheName;
174     if (!decoder.decode(cacheName))
175         return false;
176
177     options.ignoreSearch = ignoreSearch;
178     options.ignoreMethod = ignoreMethod;
179     options.ignoreVary = ignoreVary;
180     options.cacheName = WTFMove(cacheName);
181     return true;
182 }
183
184 void ArgumentCoder<FetchOptions>::encode(Encoder& encoder, const FetchOptions& options)
185 {
186     encoder << options.type;
187     encoder << options.destination;
188     encoder << options.mode;
189     encoder << options.credentials;
190     encoder << options.cache;
191     encoder << options.redirect;
192     encoder << options.referrerPolicy;
193     encoder << options.integrity;
194     encoder << options.keepAlive;
195 }
196
197 bool ArgumentCoder<FetchOptions>::decode(Decoder& decoder, FetchOptions& options)
198 {
199     FetchOptions::Type type;
200     if (!decoder.decode(type))
201         return false;
202
203     FetchOptions::Destination destination;
204     if (!decoder.decode(destination))
205         return false;
206
207     FetchOptions::Mode mode;
208     if (!decoder.decode(mode))
209         return false;
210
211     FetchOptions::Credentials credentials;
212     if (!decoder.decode(credentials))
213         return false;
214
215     FetchOptions::Cache cache;
216     if (!decoder.decode(cache))
217         return false;
218
219     FetchOptions::Redirect redirect;
220     if (!decoder.decode(redirect))
221         return false;
222
223     ReferrerPolicy referrerPolicy;
224     if (!decoder.decode(referrerPolicy))
225         return false;
226
227     String integrity;
228     if (!decoder.decode(integrity))
229         return false;
230
231     bool keepAlive;
232     if (!decoder.decode(keepAlive))
233         return false;
234
235     options.type = type;
236     options.destination = destination;
237     options.mode = mode;
238     options.credentials = credentials;
239     options.cache = cache;
240     options.redirect = redirect;
241     options.referrerPolicy = referrerPolicy;
242     options.integrity = WTFMove(integrity);
243     options.keepAlive = keepAlive;
244
245     return true;
246 }
247
248 void ArgumentCoder<CacheStorageConnection::CacheInfo>::encode(Encoder& encoder, const CacheStorageConnection::CacheInfo& info)
249 {
250     encoder << info.identifier;
251     encoder << info.name;
252 }
253
254 bool ArgumentCoder<CacheStorageConnection::CacheInfo>::decode(Decoder& decoder, CacheStorageConnection::CacheInfo& record)
255 {
256     uint64_t identifier;
257     if (!decoder.decode(identifier))
258         return false;
259
260     String name;
261     if (!decoder.decode(name))
262         return false;
263
264     record.identifier = identifier;
265     record.name = WTFMove(name);
266
267     return true;
268 }
269
270 void ArgumentCoder<CacheStorageConnection::Record>::encode(Encoder& encoder, const CacheStorageConnection::Record& record)
271 {
272     encoder << record.identifier;
273
274     encoder << record.requestHeadersGuard;
275     encoder << record.request;
276     encoder << record.options;
277     encoder << record.referrer;
278
279     encoder << record.responseHeadersGuard;
280     encoder << record.response;
281 }
282
283 bool ArgumentCoder<CacheStorageConnection::Record>::decode(Decoder& decoder, CacheStorageConnection::Record& record)
284 {
285     uint64_t identifier;
286     if (!decoder.decode(identifier))
287         return false;
288
289     FetchHeaders::Guard requestHeadersGuard;
290     if (!decoder.decode(requestHeadersGuard))
291         return false;
292
293     WebCore::ResourceRequest request;
294     if (!decoder.decode(request))
295         return false;
296
297     WebCore::FetchOptions options;
298     if (!decoder.decode(options))
299         return false;
300
301     String referrer;
302     if (!decoder.decode(referrer))
303         return false;
304
305     FetchHeaders::Guard responseHeadersGuard;
306     if (!decoder.decode(responseHeadersGuard))
307         return false;
308
309     WebCore::ResourceResponse response;
310     if (!decoder.decode(response))
311         return false;
312
313     record.identifier = identifier;
314     record.requestHeadersGuard = requestHeadersGuard;
315     record.request = WTFMove(request);
316     record.options = WTFMove(options);
317     record.referrer = WTFMove(referrer);
318
319     record.responseHeadersGuard = responseHeadersGuard;
320     record.response = WTFMove(response);
321
322     return true;
323 }
324
325 void ArgumentCoder<EventTrackingRegions>::encode(Encoder& encoder, const EventTrackingRegions& eventTrackingRegions)
326 {
327     encoder << eventTrackingRegions.asynchronousDispatchRegion;
328     encoder << eventTrackingRegions.eventSpecificSynchronousDispatchRegions;
329 }
330
331 bool ArgumentCoder<EventTrackingRegions>::decode(Decoder& decoder, EventTrackingRegions& eventTrackingRegions)
332 {
333     Region asynchronousDispatchRegion;
334     if (!decoder.decode(asynchronousDispatchRegion))
335         return false;
336     HashMap<String, Region> eventSpecificSynchronousDispatchRegions;
337     if (!decoder.decode(eventSpecificSynchronousDispatchRegions))
338         return false;
339     eventTrackingRegions.asynchronousDispatchRegion = WTFMove(asynchronousDispatchRegion);
340     eventTrackingRegions.eventSpecificSynchronousDispatchRegions = WTFMove(eventSpecificSynchronousDispatchRegions);
341     return true;
342 }
343
344 void ArgumentCoder<TransformationMatrix>::encode(Encoder& encoder, const TransformationMatrix& transformationMatrix)
345 {
346     encoder << transformationMatrix.m11();
347     encoder << transformationMatrix.m12();
348     encoder << transformationMatrix.m13();
349     encoder << transformationMatrix.m14();
350
351     encoder << transformationMatrix.m21();
352     encoder << transformationMatrix.m22();
353     encoder << transformationMatrix.m23();
354     encoder << transformationMatrix.m24();
355
356     encoder << transformationMatrix.m31();
357     encoder << transformationMatrix.m32();
358     encoder << transformationMatrix.m33();
359     encoder << transformationMatrix.m34();
360
361     encoder << transformationMatrix.m41();
362     encoder << transformationMatrix.m42();
363     encoder << transformationMatrix.m43();
364     encoder << transformationMatrix.m44();
365 }
366
367 bool ArgumentCoder<TransformationMatrix>::decode(Decoder& decoder, TransformationMatrix& transformationMatrix)
368 {
369     double m11;
370     if (!decoder.decode(m11))
371         return false;
372     double m12;
373     if (!decoder.decode(m12))
374         return false;
375     double m13;
376     if (!decoder.decode(m13))
377         return false;
378     double m14;
379     if (!decoder.decode(m14))
380         return false;
381
382     double m21;
383     if (!decoder.decode(m21))
384         return false;
385     double m22;
386     if (!decoder.decode(m22))
387         return false;
388     double m23;
389     if (!decoder.decode(m23))
390         return false;
391     double m24;
392     if (!decoder.decode(m24))
393         return false;
394
395     double m31;
396     if (!decoder.decode(m31))
397         return false;
398     double m32;
399     if (!decoder.decode(m32))
400         return false;
401     double m33;
402     if (!decoder.decode(m33))
403         return false;
404     double m34;
405     if (!decoder.decode(m34))
406         return false;
407
408     double m41;
409     if (!decoder.decode(m41))
410         return false;
411     double m42;
412     if (!decoder.decode(m42))
413         return false;
414     double m43;
415     if (!decoder.decode(m43))
416         return false;
417     double m44;
418     if (!decoder.decode(m44))
419         return false;
420
421     transformationMatrix.setMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
422     return true;
423 }
424
425 void ArgumentCoder<LinearTimingFunction>::encode(Encoder& encoder, const LinearTimingFunction& timingFunction)
426 {
427     encoder.encodeEnum(timingFunction.type());
428 }
429
430 bool ArgumentCoder<LinearTimingFunction>::decode(Decoder&, LinearTimingFunction&)
431 {
432     // Type is decoded by the caller. Nothing else to decode.
433     return true;
434 }
435
436 void ArgumentCoder<CubicBezierTimingFunction>::encode(Encoder& encoder, const CubicBezierTimingFunction& timingFunction)
437 {
438     encoder.encodeEnum(timingFunction.type());
439     
440     encoder << timingFunction.x1();
441     encoder << timingFunction.y1();
442     encoder << timingFunction.x2();
443     encoder << timingFunction.y2();
444     
445     encoder.encodeEnum(timingFunction.timingFunctionPreset());
446 }
447
448 bool ArgumentCoder<CubicBezierTimingFunction>::decode(Decoder& decoder, CubicBezierTimingFunction& timingFunction)
449 {
450     // Type is decoded by the caller.
451     double x1;
452     if (!decoder.decode(x1))
453         return false;
454
455     double y1;
456     if (!decoder.decode(y1))
457         return false;
458
459     double x2;
460     if (!decoder.decode(x2))
461         return false;
462
463     double y2;
464     if (!decoder.decode(y2))
465         return false;
466
467     CubicBezierTimingFunction::TimingFunctionPreset preset;
468     if (!decoder.decodeEnum(preset))
469         return false;
470
471     timingFunction.setValues(x1, y1, x2, y2);
472     timingFunction.setTimingFunctionPreset(preset);
473
474     return true;
475 }
476
477 void ArgumentCoder<StepsTimingFunction>::encode(Encoder& encoder, const StepsTimingFunction& timingFunction)
478 {
479     encoder.encodeEnum(timingFunction.type());
480     
481     encoder << timingFunction.numberOfSteps();
482     encoder << timingFunction.stepAtStart();
483 }
484
485 bool ArgumentCoder<StepsTimingFunction>::decode(Decoder& decoder, StepsTimingFunction& timingFunction)
486 {
487     // Type is decoded by the caller.
488     int numSteps;
489     if (!decoder.decode(numSteps))
490         return false;
491
492     bool stepAtStart;
493     if (!decoder.decode(stepAtStart))
494         return false;
495
496     timingFunction.setNumberOfSteps(numSteps);
497     timingFunction.setStepAtStart(stepAtStart);
498
499     return true;
500 }
501
502 void ArgumentCoder<SpringTimingFunction>::encode(Encoder& encoder, const SpringTimingFunction& timingFunction)
503 {
504     encoder.encodeEnum(timingFunction.type());
505     
506     encoder << timingFunction.mass();
507     encoder << timingFunction.stiffness();
508     encoder << timingFunction.damping();
509     encoder << timingFunction.initialVelocity();
510 }
511
512 bool ArgumentCoder<SpringTimingFunction>::decode(Decoder& decoder, SpringTimingFunction& timingFunction)
513 {
514     // Type is decoded by the caller.
515     double mass;
516     if (!decoder.decode(mass))
517         return false;
518
519     double stiffness;
520     if (!decoder.decode(stiffness))
521         return false;
522
523     double damping;
524     if (!decoder.decode(damping))
525         return false;
526
527     double initialVelocity;
528     if (!decoder.decode(initialVelocity))
529         return false;
530
531     timingFunction.setValues(mass, stiffness, damping, initialVelocity);
532
533     return true;
534 }
535
536 void ArgumentCoder<FloatPoint>::encode(Encoder& encoder, const FloatPoint& floatPoint)
537 {
538     SimpleArgumentCoder<FloatPoint>::encode(encoder, floatPoint);
539 }
540
541 bool ArgumentCoder<FloatPoint>::decode(Decoder& decoder, FloatPoint& floatPoint)
542 {
543     return SimpleArgumentCoder<FloatPoint>::decode(decoder, floatPoint);
544 }
545
546
547 void ArgumentCoder<FloatPoint3D>::encode(Encoder& encoder, const FloatPoint3D& floatPoint)
548 {
549     SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint);
550 }
551
552 bool ArgumentCoder<FloatPoint3D>::decode(Decoder& decoder, FloatPoint3D& floatPoint)
553 {
554     return SimpleArgumentCoder<FloatPoint3D>::decode(decoder, floatPoint);
555 }
556
557
558 void ArgumentCoder<FloatRect>::encode(Encoder& encoder, const FloatRect& floatRect)
559 {
560     SimpleArgumentCoder<FloatRect>::encode(encoder, floatRect);
561 }
562
563 bool ArgumentCoder<FloatRect>::decode(Decoder& decoder, FloatRect& floatRect)
564 {
565     return SimpleArgumentCoder<FloatRect>::decode(decoder, floatRect);
566 }
567
568
569 void ArgumentCoder<FloatBoxExtent>::encode(Encoder& encoder, const FloatBoxExtent& floatBoxExtent)
570 {
571     SimpleArgumentCoder<FloatBoxExtent>::encode(encoder, floatBoxExtent);
572 }
573     
574 bool ArgumentCoder<FloatBoxExtent>::decode(Decoder& decoder, FloatBoxExtent& floatBoxExtent)
575 {
576     return SimpleArgumentCoder<FloatBoxExtent>::decode(decoder, floatBoxExtent);
577 }
578     
579
580 void ArgumentCoder<FloatSize>::encode(Encoder& encoder, const FloatSize& floatSize)
581 {
582     SimpleArgumentCoder<FloatSize>::encode(encoder, floatSize);
583 }
584
585 bool ArgumentCoder<FloatSize>::decode(Decoder& decoder, FloatSize& floatSize)
586 {
587     return SimpleArgumentCoder<FloatSize>::decode(decoder, floatSize);
588 }
589
590
591 void ArgumentCoder<FloatRoundedRect>::encode(Encoder& encoder, const FloatRoundedRect& roundedRect)
592 {
593     SimpleArgumentCoder<FloatRoundedRect>::encode(encoder, roundedRect);
594 }
595
596 bool ArgumentCoder<FloatRoundedRect>::decode(Decoder& decoder, FloatRoundedRect& roundedRect)
597 {
598     return SimpleArgumentCoder<FloatRoundedRect>::decode(decoder, roundedRect);
599 }
600
601 #if PLATFORM(IOS)
602 void ArgumentCoder<FloatQuad>::encode(Encoder& encoder, const FloatQuad& floatQuad)
603 {
604     SimpleArgumentCoder<FloatQuad>::encode(encoder, floatQuad);
605 }
606
607 bool ArgumentCoder<FloatQuad>::decode(Decoder& decoder, FloatQuad& floatQuad)
608 {
609     return SimpleArgumentCoder<FloatQuad>::decode(decoder, floatQuad);
610 }
611
612 void ArgumentCoder<ViewportArguments>::encode(Encoder& encoder, const ViewportArguments& viewportArguments)
613 {
614     SimpleArgumentCoder<ViewportArguments>::encode(encoder, viewportArguments);
615 }
616
617 bool ArgumentCoder<ViewportArguments>::decode(Decoder& decoder, ViewportArguments& viewportArguments)
618 {
619     return SimpleArgumentCoder<ViewportArguments>::decode(decoder, viewportArguments);
620 }
621 #endif // PLATFORM(IOS)
622
623
624 void ArgumentCoder<IntPoint>::encode(Encoder& encoder, const IntPoint& intPoint)
625 {
626     SimpleArgumentCoder<IntPoint>::encode(encoder, intPoint);
627 }
628
629 bool ArgumentCoder<IntPoint>::decode(Decoder& decoder, IntPoint& intPoint)
630 {
631     return SimpleArgumentCoder<IntPoint>::decode(decoder, intPoint);
632 }
633
634
635 void ArgumentCoder<IntRect>::encode(Encoder& encoder, const IntRect& intRect)
636 {
637     SimpleArgumentCoder<IntRect>::encode(encoder, intRect);
638 }
639
640 bool ArgumentCoder<IntRect>::decode(Decoder& decoder, IntRect& intRect)
641 {
642     return SimpleArgumentCoder<IntRect>::decode(decoder, intRect);
643 }
644
645
646 void ArgumentCoder<IntSize>::encode(Encoder& encoder, const IntSize& intSize)
647 {
648     SimpleArgumentCoder<IntSize>::encode(encoder, intSize);
649 }
650
651 bool ArgumentCoder<IntSize>::decode(Decoder& decoder, IntSize& intSize)
652 {
653     return SimpleArgumentCoder<IntSize>::decode(decoder, intSize);
654 }
655
656
657 void ArgumentCoder<LayoutSize>::encode(Encoder& encoder, const LayoutSize& layoutSize)
658 {
659     SimpleArgumentCoder<LayoutSize>::encode(encoder, layoutSize);
660 }
661
662 bool ArgumentCoder<LayoutSize>::decode(Decoder& decoder, LayoutSize& layoutSize)
663 {
664     return SimpleArgumentCoder<LayoutSize>::decode(decoder, layoutSize);
665 }
666
667
668 void ArgumentCoder<LayoutPoint>::encode(Encoder& encoder, const LayoutPoint& layoutPoint)
669 {
670     SimpleArgumentCoder<LayoutPoint>::encode(encoder, layoutPoint);
671 }
672
673 bool ArgumentCoder<LayoutPoint>::decode(Decoder& decoder, LayoutPoint& layoutPoint)
674 {
675     return SimpleArgumentCoder<LayoutPoint>::decode(decoder, layoutPoint);
676 }
677
678
679 static void pathEncodeApplierFunction(Encoder& encoder, const PathElement& element)
680 {
681     encoder.encodeEnum(element.type);
682
683     switch (element.type) {
684     case PathElementMoveToPoint: // The points member will contain 1 value.
685         encoder << element.points[0];
686         break;
687     case PathElementAddLineToPoint: // The points member will contain 1 value.
688         encoder << element.points[0];
689         break;
690     case PathElementAddQuadCurveToPoint: // The points member will contain 2 values.
691         encoder << element.points[0];
692         encoder << element.points[1];
693         break;
694     case PathElementAddCurveToPoint: // The points member will contain 3 values.
695         encoder << element.points[0];
696         encoder << element.points[1];
697         encoder << element.points[2];
698         break;
699     case PathElementCloseSubpath: // The points member will contain no values.
700         break;
701     }
702 }
703
704 void ArgumentCoder<Path>::encode(Encoder& encoder, const Path& path)
705 {
706     uint64_t numPoints = 0;
707     path.apply([&numPoints](const PathElement&) {
708         ++numPoints;
709     });
710
711     encoder << numPoints;
712
713     path.apply([&encoder](const PathElement& pathElement) {
714         pathEncodeApplierFunction(encoder, pathElement);
715     });
716 }
717
718 bool ArgumentCoder<Path>::decode(Decoder& decoder, Path& path)
719 {
720     uint64_t numPoints;
721     if (!decoder.decode(numPoints))
722         return false;
723     
724     path.clear();
725
726     for (uint64_t i = 0; i < numPoints; ++i) {
727     
728         PathElementType elementType;
729         if (!decoder.decodeEnum(elementType))
730             return false;
731         
732         switch (elementType) {
733         case PathElementMoveToPoint: { // The points member will contain 1 value.
734             FloatPoint point;
735             if (!decoder.decode(point))
736                 return false;
737             path.moveTo(point);
738             break;
739         }
740         case PathElementAddLineToPoint: { // The points member will contain 1 value.
741             FloatPoint point;
742             if (!decoder.decode(point))
743                 return false;
744             path.addLineTo(point);
745             break;
746         }
747         case PathElementAddQuadCurveToPoint: { // The points member will contain 2 values.
748             FloatPoint controlPoint;
749             if (!decoder.decode(controlPoint))
750                 return false;
751
752             FloatPoint endPoint;
753             if (!decoder.decode(endPoint))
754                 return false;
755
756             path.addQuadCurveTo(controlPoint, endPoint);
757             break;
758         }
759         case PathElementAddCurveToPoint: { // The points member will contain 3 values.
760             FloatPoint controlPoint1;
761             if (!decoder.decode(controlPoint1))
762                 return false;
763
764             FloatPoint controlPoint2;
765             if (!decoder.decode(controlPoint2))
766                 return false;
767
768             FloatPoint endPoint;
769             if (!decoder.decode(endPoint))
770                 return false;
771
772             path.addBezierCurveTo(controlPoint1, controlPoint2, endPoint);
773             break;
774         }
775         case PathElementCloseSubpath: // The points member will contain no values.
776             path.closeSubpath();
777             break;
778         }
779     }
780
781     return true;
782 }
783
784 void ArgumentCoder<RecentSearch>::encode(Encoder& encoder, const RecentSearch& recentSearch)
785 {
786     encoder << recentSearch.string << recentSearch.time;
787 }
788
789 bool ArgumentCoder<RecentSearch>::decode(Decoder& decoder, RecentSearch& recentSearch)
790 {
791     if (!decoder.decode(recentSearch.string))
792         return false;
793
794     if (!decoder.decode(recentSearch.time))
795         return false;
796
797     return true;
798 }
799
800 template<> struct ArgumentCoder<Region::Span> {
801     static void encode(Encoder&, const Region::Span&);
802     static bool decode(Decoder&, Region::Span&);
803 };
804
805 void ArgumentCoder<Region::Span>::encode(Encoder& encoder, const Region::Span& span)
806 {
807     encoder << span.y;
808     encoder << (uint64_t)span.segmentIndex;
809 }
810
811 bool ArgumentCoder<Region::Span>::decode(Decoder& decoder, Region::Span& span)
812 {
813     if (!decoder.decode(span.y))
814         return false;
815     
816     uint64_t segmentIndex;
817     if (!decoder.decode(segmentIndex))
818         return false;
819     
820     span.segmentIndex = segmentIndex;
821     return true;
822 }
823
824 void ArgumentCoder<Region>::encode(Encoder& encoder, const Region& region)
825 {
826     encoder.encode(region.shapeSegments());
827     encoder.encode(region.shapeSpans());
828 }
829
830 bool ArgumentCoder<Region>::decode(Decoder& decoder, Region& region)
831 {
832     Vector<int> segments;
833     if (!decoder.decode(segments))
834         return false;
835
836     Vector<Region::Span> spans;
837     if (!decoder.decode(spans))
838         return false;
839     
840     region.setShapeSegments(segments);
841     region.setShapeSpans(spans);
842     region.updateBoundsFromShape();
843     
844     if (!region.isValid())
845         return false;
846
847     return true;
848 }
849
850 void ArgumentCoder<Length>::encode(Encoder& encoder, const Length& length)
851 {
852     SimpleArgumentCoder<Length>::encode(encoder, length);
853 }
854
855 bool ArgumentCoder<Length>::decode(Decoder& decoder, Length& length)
856 {
857     return SimpleArgumentCoder<Length>::decode(decoder, length);
858 }
859
860
861 void ArgumentCoder<ViewportAttributes>::encode(Encoder& encoder, const ViewportAttributes& viewportAttributes)
862 {
863     SimpleArgumentCoder<ViewportAttributes>::encode(encoder, viewportAttributes);
864 }
865
866 bool ArgumentCoder<ViewportAttributes>::decode(Decoder& decoder, ViewportAttributes& viewportAttributes)
867 {
868     return SimpleArgumentCoder<ViewportAttributes>::decode(decoder, viewportAttributes);
869 }
870
871
872 void ArgumentCoder<MimeClassInfo>::encode(Encoder& encoder, const MimeClassInfo& mimeClassInfo)
873 {
874     encoder << mimeClassInfo.type << mimeClassInfo.desc << mimeClassInfo.extensions;
875 }
876
877 bool ArgumentCoder<MimeClassInfo>::decode(Decoder& decoder, MimeClassInfo& mimeClassInfo)
878 {
879     if (!decoder.decode(mimeClassInfo.type))
880         return false;
881     if (!decoder.decode(mimeClassInfo.desc))
882         return false;
883     if (!decoder.decode(mimeClassInfo.extensions))
884         return false;
885
886     return true;
887 }
888
889
890 void ArgumentCoder<PluginInfo>::encode(Encoder& encoder, const PluginInfo& pluginInfo)
891 {
892     encoder << pluginInfo.name;
893     encoder << pluginInfo.file;
894     encoder << pluginInfo.desc;
895     encoder << pluginInfo.mimes;
896     encoder << pluginInfo.isApplicationPlugin;
897     encoder.encodeEnum(pluginInfo.clientLoadPolicy);
898 #if PLATFORM(MAC)
899     encoder << pluginInfo.bundleIdentifier;
900     encoder << pluginInfo.versionString;
901 #endif
902 }
903
904 bool ArgumentCoder<PluginInfo>::decode(Decoder& decoder, PluginInfo& pluginInfo)
905 {
906     if (!decoder.decode(pluginInfo.name))
907         return false;
908     if (!decoder.decode(pluginInfo.file))
909         return false;
910     if (!decoder.decode(pluginInfo.desc))
911         return false;
912     if (!decoder.decode(pluginInfo.mimes))
913         return false;
914     if (!decoder.decode(pluginInfo.isApplicationPlugin))
915         return false;
916     if (!decoder.decodeEnum(pluginInfo.clientLoadPolicy))
917         return false;
918 #if PLATFORM(MAC)
919     if (!decoder.decode(pluginInfo.bundleIdentifier))
920         return false;
921     if (!decoder.decode(pluginInfo.versionString))
922         return false;
923 #endif
924
925     return true;
926 }
927
928 void ArgumentCoder<AuthenticationChallenge>::encode(Encoder& encoder, const AuthenticationChallenge& challenge)
929 {
930     encoder << challenge.protectionSpace() << challenge.proposedCredential() << challenge.previousFailureCount() << challenge.failureResponse() << challenge.error();
931 }
932
933 bool ArgumentCoder<AuthenticationChallenge>::decode(Decoder& decoder, AuthenticationChallenge& challenge)
934 {    
935     ProtectionSpace protectionSpace;
936     if (!decoder.decode(protectionSpace))
937         return false;
938
939     Credential proposedCredential;
940     if (!decoder.decode(proposedCredential))
941         return false;
942
943     unsigned previousFailureCount;    
944     if (!decoder.decode(previousFailureCount))
945         return false;
946
947     ResourceResponse failureResponse;
948     if (!decoder.decode(failureResponse))
949         return false;
950
951     ResourceError error;
952     if (!decoder.decode(error))
953         return false;
954     
955     challenge = AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
956     return true;
957 }
958
959
960 void ArgumentCoder<ProtectionSpace>::encode(Encoder& encoder, const ProtectionSpace& space)
961 {
962     if (space.encodingRequiresPlatformData()) {
963         encoder << true;
964         encodePlatformData(encoder, space);
965         return;
966     }
967
968     encoder << false;
969     encoder << space.host() << space.port() << space.realm();
970     encoder.encodeEnum(space.authenticationScheme());
971     encoder.encodeEnum(space.serverType());
972 }
973
974 bool ArgumentCoder<ProtectionSpace>::decode(Decoder& decoder, ProtectionSpace& space)
975 {
976     bool hasPlatformData;
977     if (!decoder.decode(hasPlatformData))
978         return false;
979
980     if (hasPlatformData)
981         return decodePlatformData(decoder, space);
982
983     String host;
984     if (!decoder.decode(host))
985         return false;
986
987     int port;
988     if (!decoder.decode(port))
989         return false;
990
991     String realm;
992     if (!decoder.decode(realm))
993         return false;
994     
995     ProtectionSpaceAuthenticationScheme authenticationScheme;
996     if (!decoder.decodeEnum(authenticationScheme))
997         return false;
998
999     ProtectionSpaceServerType serverType;
1000     if (!decoder.decodeEnum(serverType))
1001         return false;
1002
1003     space = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
1004     return true;
1005 }
1006
1007 void ArgumentCoder<Credential>::encode(Encoder& encoder, const Credential& credential)
1008 {
1009     if (credential.encodingRequiresPlatformData()) {
1010         encoder << true;
1011         encodePlatformData(encoder, credential);
1012         return;
1013     }
1014
1015     encoder << false;
1016     encoder << credential.user() << credential.password();
1017     encoder.encodeEnum(credential.persistence());
1018 }
1019
1020 bool ArgumentCoder<Credential>::decode(Decoder& decoder, Credential& credential)
1021 {
1022     bool hasPlatformData;
1023     if (!decoder.decode(hasPlatformData))
1024         return false;
1025
1026     if (hasPlatformData)
1027         return decodePlatformData(decoder, credential);
1028
1029     String user;
1030     if (!decoder.decode(user))
1031         return false;
1032
1033     String password;
1034     if (!decoder.decode(password))
1035         return false;
1036
1037     CredentialPersistence persistence;
1038     if (!decoder.decodeEnum(persistence))
1039         return false;
1040     
1041     credential = Credential(user, password, persistence);
1042     return true;
1043 }
1044
1045 static void encodeImage(Encoder& encoder, Image& image)
1046 {
1047     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(IntSize(image.size()), ShareableBitmap::SupportsAlpha);
1048     bitmap->createGraphicsContext()->drawImage(image, IntPoint());
1049
1050     ShareableBitmap::Handle handle;
1051     bitmap->createHandle(handle);
1052
1053     encoder << handle;
1054 }
1055
1056 static bool decodeImage(Decoder& decoder, RefPtr<Image>& image)
1057 {
1058     ShareableBitmap::Handle handle;
1059     if (!decoder.decode(handle))
1060         return false;
1061     
1062     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
1063     if (!bitmap)
1064         return false;
1065     image = bitmap->createImage();
1066     if (!image)
1067         return false;
1068     return true;
1069 }
1070
1071 static void encodeOptionalImage(Encoder& encoder, Image* image)
1072 {
1073     bool hasImage = !!image;
1074     encoder << hasImage;
1075
1076     if (hasImage)
1077         encodeImage(encoder, *image);
1078 }
1079
1080 static bool decodeOptionalImage(Decoder& decoder, RefPtr<Image>& image)
1081 {
1082     image = nullptr;
1083
1084     bool hasImage;
1085     if (!decoder.decode(hasImage))
1086         return false;
1087
1088     if (!hasImage)
1089         return true;
1090
1091     return decodeImage(decoder, image);
1092 }
1093
1094 #if !PLATFORM(IOS)
1095 void ArgumentCoder<Cursor>::encode(Encoder& encoder, const Cursor& cursor)
1096 {
1097     encoder.encodeEnum(cursor.type());
1098         
1099     if (cursor.type() != Cursor::Custom)
1100         return;
1101
1102     if (cursor.image()->isNull()) {
1103         encoder << false; // There is no valid image being encoded.
1104         return;
1105     }
1106
1107     encoder << true;
1108     encodeImage(encoder, *cursor.image());
1109     encoder << cursor.hotSpot();
1110 #if ENABLE(MOUSE_CURSOR_SCALE)
1111     encoder << cursor.imageScaleFactor();
1112 #endif
1113 }
1114
1115 bool ArgumentCoder<Cursor>::decode(Decoder& decoder, Cursor& cursor)
1116 {
1117     Cursor::Type type;
1118     if (!decoder.decodeEnum(type))
1119         return false;
1120
1121     if (type > Cursor::Custom)
1122         return false;
1123
1124     if (type != Cursor::Custom) {
1125         const Cursor& cursorReference = Cursor::fromType(type);
1126         // Calling platformCursor here will eagerly create the platform cursor for the cursor singletons inside WebCore.
1127         // This will avoid having to re-create the platform cursors over and over.
1128         (void)cursorReference.platformCursor();
1129
1130         cursor = cursorReference;
1131         return true;
1132     }
1133
1134     bool isValidImagePresent;
1135     if (!decoder.decode(isValidImagePresent))
1136         return false;
1137
1138     if (!isValidImagePresent) {
1139         cursor = Cursor(&Image::nullImage(), IntPoint());
1140         return true;
1141     }
1142
1143     RefPtr<Image> image;
1144     if (!decodeImage(decoder, image))
1145         return false;
1146
1147     IntPoint hotSpot;
1148     if (!decoder.decode(hotSpot))
1149         return false;
1150
1151     if (!image->rect().contains(hotSpot))
1152         return false;
1153
1154 #if ENABLE(MOUSE_CURSOR_SCALE)
1155     float scale;
1156     if (!decoder.decode(scale))
1157         return false;
1158
1159     cursor = Cursor(image.get(), hotSpot, scale);
1160 #else
1161     cursor = Cursor(image.get(), hotSpot);
1162 #endif
1163     return true;
1164 }
1165 #endif
1166
1167 void ArgumentCoder<ResourceRequest>::encode(Encoder& encoder, const ResourceRequest& resourceRequest)
1168 {
1169     encoder << resourceRequest.cachePartition();
1170     encoder << resourceRequest.hiddenFromInspector();
1171
1172     if (resourceRequest.encodingRequiresPlatformData()) {
1173         encoder << true;
1174         encodePlatformData(encoder, resourceRequest);
1175         return;
1176     }
1177     encoder << false;
1178     resourceRequest.encodeWithoutPlatformData(encoder);
1179 }
1180
1181 bool ArgumentCoder<ResourceRequest>::decode(Decoder& decoder, ResourceRequest& resourceRequest)
1182 {
1183     String cachePartition;
1184     if (!decoder.decode(cachePartition))
1185         return false;
1186     resourceRequest.setCachePartition(cachePartition);
1187
1188     bool isHiddenFromInspector;
1189     if (!decoder.decode(isHiddenFromInspector))
1190         return false;
1191     resourceRequest.setHiddenFromInspector(isHiddenFromInspector);
1192
1193     bool hasPlatformData;
1194     if (!decoder.decode(hasPlatformData))
1195         return false;
1196     if (hasPlatformData)
1197         return decodePlatformData(decoder, resourceRequest);
1198
1199     return resourceRequest.decodeWithoutPlatformData(decoder);
1200 }
1201
1202 void ArgumentCoder<ResourceError>::encode(Encoder& encoder, const ResourceError& resourceError)
1203 {
1204     encodePlatformData(encoder, resourceError);
1205 }
1206
1207 bool ArgumentCoder<ResourceError>::decode(Decoder& decoder, ResourceError& resourceError)
1208 {
1209     return decodePlatformData(decoder, resourceError);
1210 }
1211
1212 #if PLATFORM(IOS)
1213
1214 void ArgumentCoder<SelectionRect>::encode(Encoder& encoder, const SelectionRect& selectionRect)
1215 {
1216     encoder << selectionRect.rect();
1217     encoder << static_cast<uint32_t>(selectionRect.direction());
1218     encoder << selectionRect.minX();
1219     encoder << selectionRect.maxX();
1220     encoder << selectionRect.maxY();
1221     encoder << selectionRect.lineNumber();
1222     encoder << selectionRect.isLineBreak();
1223     encoder << selectionRect.isFirstOnLine();
1224     encoder << selectionRect.isLastOnLine();
1225     encoder << selectionRect.containsStart();
1226     encoder << selectionRect.containsEnd();
1227     encoder << selectionRect.isHorizontal();
1228 }
1229
1230 bool ArgumentCoder<SelectionRect>::decode(Decoder& decoder, SelectionRect& selectionRect)
1231 {
1232     IntRect rect;
1233     if (!decoder.decode(rect))
1234         return false;
1235     selectionRect.setRect(rect);
1236
1237     uint32_t direction;
1238     if (!decoder.decode(direction))
1239         return false;
1240     selectionRect.setDirection((TextDirection)direction);
1241
1242     int intValue;
1243     if (!decoder.decode(intValue))
1244         return false;
1245     selectionRect.setMinX(intValue);
1246
1247     if (!decoder.decode(intValue))
1248         return false;
1249     selectionRect.setMaxX(intValue);
1250
1251     if (!decoder.decode(intValue))
1252         return false;
1253     selectionRect.setMaxY(intValue);
1254
1255     if (!decoder.decode(intValue))
1256         return false;
1257     selectionRect.setLineNumber(intValue);
1258
1259     bool boolValue;
1260     if (!decoder.decode(boolValue))
1261         return false;
1262     selectionRect.setIsLineBreak(boolValue);
1263
1264     if (!decoder.decode(boolValue))
1265         return false;
1266     selectionRect.setIsFirstOnLine(boolValue);
1267
1268     if (!decoder.decode(boolValue))
1269         return false;
1270     selectionRect.setIsLastOnLine(boolValue);
1271
1272     if (!decoder.decode(boolValue))
1273         return false;
1274     selectionRect.setContainsStart(boolValue);
1275
1276     if (!decoder.decode(boolValue))
1277         return false;
1278     selectionRect.setContainsEnd(boolValue);
1279
1280     if (!decoder.decode(boolValue))
1281         return false;
1282     selectionRect.setIsHorizontal(boolValue);
1283
1284     return true;
1285 }
1286
1287 #endif
1288
1289 void ArgumentCoder<WindowFeatures>::encode(Encoder& encoder, const WindowFeatures& windowFeatures)
1290 {
1291     encoder << windowFeatures.x;
1292     encoder << windowFeatures.y;
1293     encoder << windowFeatures.width;
1294     encoder << windowFeatures.height;
1295     encoder << windowFeatures.menuBarVisible;
1296     encoder << windowFeatures.statusBarVisible;
1297     encoder << windowFeatures.toolBarVisible;
1298     encoder << windowFeatures.locationBarVisible;
1299     encoder << windowFeatures.scrollbarsVisible;
1300     encoder << windowFeatures.resizable;
1301     encoder << windowFeatures.fullscreen;
1302     encoder << windowFeatures.dialog;
1303 }
1304
1305 bool ArgumentCoder<WindowFeatures>::decode(Decoder& decoder, WindowFeatures& windowFeatures)
1306 {
1307     if (!decoder.decode(windowFeatures.x))
1308         return false;
1309     if (!decoder.decode(windowFeatures.y))
1310         return false;
1311     if (!decoder.decode(windowFeatures.width))
1312         return false;
1313     if (!decoder.decode(windowFeatures.height))
1314         return false;
1315     if (!decoder.decode(windowFeatures.menuBarVisible))
1316         return false;
1317     if (!decoder.decode(windowFeatures.statusBarVisible))
1318         return false;
1319     if (!decoder.decode(windowFeatures.toolBarVisible))
1320         return false;
1321     if (!decoder.decode(windowFeatures.locationBarVisible))
1322         return false;
1323     if (!decoder.decode(windowFeatures.scrollbarsVisible))
1324         return false;
1325     if (!decoder.decode(windowFeatures.resizable))
1326         return false;
1327     if (!decoder.decode(windowFeatures.fullscreen))
1328         return false;
1329     if (!decoder.decode(windowFeatures.dialog))
1330         return false;
1331     return true;
1332 }
1333
1334
1335 void ArgumentCoder<Color>::encode(Encoder& encoder, const Color& color)
1336 {
1337     if (color.isExtended()) {
1338         encoder << true;
1339         encoder << color.asExtended().red();
1340         encoder << color.asExtended().green();
1341         encoder << color.asExtended().blue();
1342         encoder << color.asExtended().alpha();
1343         encoder << color.asExtended().colorSpace();
1344         return;
1345     }
1346
1347     encoder << false;
1348
1349     if (!color.isValid()) {
1350         encoder << false;
1351         return;
1352     }
1353
1354     encoder << true;
1355     encoder << color.rgb();
1356 }
1357
1358 bool ArgumentCoder<Color>::decode(Decoder& decoder, Color& color)
1359 {
1360     bool isExtended;
1361     if (!decoder.decode(isExtended))
1362         return false;
1363
1364     if (isExtended) {
1365         float red;
1366         float green;
1367         float blue;
1368         float alpha;
1369         ColorSpace colorSpace;
1370         if (!decoder.decode(red))
1371             return false;
1372         if (!decoder.decode(green))
1373             return false;
1374         if (!decoder.decode(blue))
1375             return false;
1376         if (!decoder.decode(alpha))
1377             return false;
1378         if (!decoder.decode(colorSpace))
1379             return false;
1380         color = Color(red, green, blue, alpha, colorSpace);
1381         return true;
1382     }
1383
1384     bool isValid;
1385     if (!decoder.decode(isValid))
1386         return false;
1387
1388     if (!isValid) {
1389         color = Color();
1390         return true;
1391     }
1392
1393     RGBA32 rgba;
1394     if (!decoder.decode(rgba))
1395         return false;
1396
1397     color = Color(rgba);
1398     return true;
1399 }
1400
1401 #if ENABLE(DRAG_SUPPORT)
1402 void ArgumentCoder<DragData>::encode(Encoder& encoder, const DragData& dragData)
1403 {
1404     encoder << dragData.clientPosition();
1405     encoder << dragData.globalPosition();
1406     encoder.encodeEnum(dragData.draggingSourceOperationMask());
1407     encoder.encodeEnum(dragData.flags());
1408 #if PLATFORM(COCOA)
1409     encoder << dragData.pasteboardName();
1410     encoder << dragData.fileNames();
1411 #endif
1412     encoder.encodeEnum(dragData.dragDestinationAction());
1413 }
1414
1415 bool ArgumentCoder<DragData>::decode(Decoder& decoder, DragData& dragData)
1416 {
1417     IntPoint clientPosition;
1418     if (!decoder.decode(clientPosition))
1419         return false;
1420
1421     IntPoint globalPosition;
1422     if (!decoder.decode(globalPosition))
1423         return false;
1424
1425     DragOperation draggingSourceOperationMask;
1426     if (!decoder.decodeEnum(draggingSourceOperationMask))
1427         return false;
1428
1429     DragApplicationFlags applicationFlags;
1430     if (!decoder.decodeEnum(applicationFlags))
1431         return false;
1432
1433     String pasteboardName;
1434     Vector<String> fileNames;
1435 #if PLATFORM(COCOA)
1436     if (!decoder.decode(pasteboardName))
1437         return false;
1438
1439     if (!decoder.decode(fileNames))
1440         return false;
1441 #endif
1442
1443     DragDestinationAction destinationAction;
1444     if (!decoder.decodeEnum(destinationAction))
1445         return false;
1446
1447     dragData = DragData(pasteboardName, clientPosition, globalPosition, draggingSourceOperationMask, applicationFlags, destinationAction);
1448     dragData.setFileNames(fileNames);
1449
1450     return true;
1451 }
1452 #endif
1453
1454 void ArgumentCoder<CompositionUnderline>::encode(Encoder& encoder, const CompositionUnderline& underline)
1455 {
1456     encoder << underline.startOffset;
1457     encoder << underline.endOffset;
1458     encoder << underline.thick;
1459     encoder << underline.color;
1460 }
1461
1462 bool ArgumentCoder<CompositionUnderline>::decode(Decoder& decoder, CompositionUnderline& underline)
1463 {
1464     if (!decoder.decode(underline.startOffset))
1465         return false;
1466     if (!decoder.decode(underline.endOffset))
1467         return false;
1468     if (!decoder.decode(underline.thick))
1469         return false;
1470     if (!decoder.decode(underline.color))
1471         return false;
1472
1473     return true;
1474 }
1475
1476 void ArgumentCoder<DatabaseDetails>::encode(Encoder& encoder, const DatabaseDetails& details)
1477 {
1478     encoder << details.name();
1479     encoder << details.displayName();
1480     encoder << details.expectedUsage();
1481     encoder << details.currentUsage();
1482     encoder << details.creationTime();
1483     encoder << details.modificationTime();
1484 }
1485     
1486 bool ArgumentCoder<DatabaseDetails>::decode(Decoder& decoder, DatabaseDetails& details)
1487 {
1488     String name;
1489     if (!decoder.decode(name))
1490         return false;
1491
1492     String displayName;
1493     if (!decoder.decode(displayName))
1494         return false;
1495
1496     uint64_t expectedUsage;
1497     if (!decoder.decode(expectedUsage))
1498         return false;
1499
1500     uint64_t currentUsage;
1501     if (!decoder.decode(currentUsage))
1502         return false;
1503
1504     double creationTime;
1505     if (!decoder.decode(creationTime))
1506         return false;
1507
1508     double modificationTime;
1509     if (!decoder.decode(modificationTime))
1510         return false;
1511
1512     details = DatabaseDetails(name, displayName, expectedUsage, currentUsage, creationTime, modificationTime);
1513     return true;
1514 }
1515
1516 #if PLATFORM(IOS)
1517
1518 void ArgumentCoder<Highlight>::encode(Encoder& encoder, const Highlight& highlight)
1519 {
1520     encoder << static_cast<uint32_t>(highlight.type);
1521     encoder << highlight.usePageCoordinates;
1522     encoder << highlight.contentColor;
1523     encoder << highlight.contentOutlineColor;
1524     encoder << highlight.paddingColor;
1525     encoder << highlight.borderColor;
1526     encoder << highlight.marginColor;
1527     encoder << highlight.quads;
1528 }
1529
1530 bool ArgumentCoder<Highlight>::decode(Decoder& decoder, Highlight& highlight)
1531 {
1532     uint32_t type;
1533     if (!decoder.decode(type))
1534         return false;
1535     highlight.type = (HighlightType)type;
1536
1537     if (!decoder.decode(highlight.usePageCoordinates))
1538         return false;
1539     if (!decoder.decode(highlight.contentColor))
1540         return false;
1541     if (!decoder.decode(highlight.contentOutlineColor))
1542         return false;
1543     if (!decoder.decode(highlight.paddingColor))
1544         return false;
1545     if (!decoder.decode(highlight.borderColor))
1546         return false;
1547     if (!decoder.decode(highlight.marginColor))
1548         return false;
1549     if (!decoder.decode(highlight.quads))
1550         return false;
1551     return true;
1552 }
1553
1554 static void encodeSharedBuffer(Encoder& encoder, SharedBuffer* buffer)
1555 {
1556     SharedMemory::Handle handle;
1557     encoder << (buffer ? static_cast<uint64_t>(buffer->size()): 0);
1558     if (buffer) {
1559         RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::allocate(buffer->size());
1560         memcpy(sharedMemoryBuffer->data(), buffer->data(), buffer->size());
1561         sharedMemoryBuffer->createHandle(handle, SharedMemory::Protection::ReadOnly);
1562         encoder << handle;
1563     }
1564 }
1565
1566 static bool decodeSharedBuffer(Decoder& decoder, RefPtr<SharedBuffer>& buffer)
1567 {
1568     uint64_t bufferSize = 0;
1569     if (!decoder.decode(bufferSize))
1570         return false;
1571
1572     if (bufferSize) {
1573         SharedMemory::Handle handle;
1574         if (!decoder.decode(handle))
1575             return false;
1576
1577         RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::map(handle, SharedMemory::Protection::ReadOnly);
1578         buffer = SharedBuffer::create(static_cast<unsigned char*>(sharedMemoryBuffer->data()), bufferSize);
1579     }
1580
1581     return true;
1582 }
1583
1584 void ArgumentCoder<PasteboardURL>::encode(Encoder& encoder, const PasteboardURL& content)
1585 {
1586     encoder << content.url;
1587     encoder << content.title;
1588 }
1589
1590 bool ArgumentCoder<PasteboardURL>::decode(Decoder& decoder, PasteboardURL& content)
1591 {
1592     if (!decoder.decode(content.url))
1593         return false;
1594
1595     if (!decoder.decode(content.title))
1596         return false;
1597
1598     return true;
1599 }
1600
1601 static void encodeClientTypesAndData(Encoder& encoder, const Vector<String>& types, const Vector<RefPtr<SharedBuffer>>& data)
1602 {
1603     ASSERT(types.size() == data.size());
1604     encoder << types;
1605     encoder << static_cast<uint64_t>(data.size());
1606     for (auto& buffer : data)
1607         encodeSharedBuffer(encoder, buffer.get());
1608 }
1609
1610 static bool decodeClientTypesAndData(Decoder& decoder, Vector<String>& types, Vector<RefPtr<SharedBuffer>>& data)
1611 {
1612     if (!decoder.decode(types))
1613         return false;
1614
1615     uint64_t dataSize;
1616     if (!decoder.decode(dataSize))
1617         return false;
1618
1619     ASSERT(dataSize == types.size());
1620
1621     data.resize(dataSize);
1622     for (auto& buffer : data)
1623         decodeSharedBuffer(decoder, buffer);
1624
1625     return true;
1626 }
1627
1628 void ArgumentCoder<PasteboardWebContent>::encode(Encoder& encoder, const PasteboardWebContent& content)
1629 {
1630     encoder << content.canSmartCopyOrDelete;
1631     encoder << content.dataInStringFormat;
1632
1633     encodeSharedBuffer(encoder, content.dataInWebArchiveFormat.get());
1634     encodeSharedBuffer(encoder, content.dataInRTFDFormat.get());
1635     encodeSharedBuffer(encoder, content.dataInRTFFormat.get());
1636     encodeSharedBuffer(encoder, content.dataInAttributedStringFormat.get());
1637
1638     encodeClientTypesAndData(encoder, content.clientTypes, content.clientData);
1639 }
1640
1641 bool ArgumentCoder<PasteboardWebContent>::decode(Decoder& decoder, PasteboardWebContent& content)
1642 {
1643     if (!decoder.decode(content.canSmartCopyOrDelete))
1644         return false;
1645     if (!decoder.decode(content.dataInStringFormat))
1646         return false;
1647     if (!decodeSharedBuffer(decoder, content.dataInWebArchiveFormat))
1648         return false;
1649     if (!decodeSharedBuffer(decoder, content.dataInRTFDFormat))
1650         return false;
1651     if (!decodeSharedBuffer(decoder, content.dataInRTFFormat))
1652         return false;
1653     if (!decodeSharedBuffer(decoder, content.dataInAttributedStringFormat))
1654         return false;
1655     if (!decodeClientTypesAndData(decoder, content.clientTypes, content.clientData))
1656         return false;
1657     return true;
1658 }
1659
1660 void ArgumentCoder<PasteboardImage>::encode(Encoder& encoder, const PasteboardImage& pasteboardImage)
1661 {
1662     encodeOptionalImage(encoder, pasteboardImage.image.get());
1663     encoder << pasteboardImage.url.url;
1664     encoder << pasteboardImage.url.title;
1665     encoder << pasteboardImage.resourceMIMEType;
1666     encoder << pasteboardImage.suggestedName;
1667     encoder << pasteboardImage.imageSize;
1668     if (pasteboardImage.resourceData)
1669         encodeSharedBuffer(encoder, pasteboardImage.resourceData.get());
1670     encodeClientTypesAndData(encoder, pasteboardImage.clientTypes, pasteboardImage.clientData);
1671 }
1672
1673 bool ArgumentCoder<PasteboardImage>::decode(Decoder& decoder, PasteboardImage& pasteboardImage)
1674 {
1675     if (!decodeOptionalImage(decoder, pasteboardImage.image))
1676         return false;
1677     if (!decoder.decode(pasteboardImage.url.url))
1678         return false;
1679     if (!decoder.decode(pasteboardImage.url.title))
1680         return false;
1681     if (!decoder.decode(pasteboardImage.resourceMIMEType))
1682         return false;
1683     if (!decoder.decode(pasteboardImage.suggestedName))
1684         return false;
1685     if (!decoder.decode(pasteboardImage.imageSize))
1686         return false;
1687     if (!decodeSharedBuffer(decoder, pasteboardImage.resourceData))
1688         return false;
1689     if (!decodeClientTypesAndData(decoder, pasteboardImage.clientTypes, pasteboardImage.clientData))
1690         return false;
1691     return true;
1692 }
1693
1694 #endif
1695
1696 #if PLATFORM(WPE)
1697 void ArgumentCoder<PasteboardWebContent>::encode(Encoder& encoder, const PasteboardWebContent& content)
1698 {
1699     encoder << content.text;
1700     encoder << content.markup;
1701 }
1702
1703 bool ArgumentCoder<PasteboardWebContent>::decode(Decoder& decoder, PasteboardWebContent& content)
1704 {
1705     if (!decoder.decode(content.text))
1706         return false;
1707     if (!decoder.decode(content.markup))
1708         return false;
1709     return true;
1710 }
1711 #endif // PLATFORM(WPE)
1712
1713 void ArgumentCoder<DictationAlternative>::encode(Encoder& encoder, const DictationAlternative& dictationAlternative)
1714 {
1715     encoder << dictationAlternative.rangeStart;
1716     encoder << dictationAlternative.rangeLength;
1717     encoder << dictationAlternative.dictationContext;
1718 }
1719
1720 bool ArgumentCoder<DictationAlternative>::decode(Decoder& decoder, DictationAlternative& dictationAlternative)
1721 {
1722     if (!decoder.decode(dictationAlternative.rangeStart))
1723         return false;
1724     if (!decoder.decode(dictationAlternative.rangeLength))
1725         return false;
1726     if (!decoder.decode(dictationAlternative.dictationContext))
1727         return false;
1728     return true;
1729 }
1730
1731
1732 void ArgumentCoder<FileChooserSettings>::encode(Encoder& encoder, const FileChooserSettings& settings)
1733 {
1734     encoder << settings.allowsMultipleFiles;
1735     encoder << settings.acceptMIMETypes;
1736     encoder << settings.acceptFileExtensions;
1737     encoder << settings.selectedFiles;
1738 #if ENABLE(MEDIA_CAPTURE)
1739     encoder.encodeEnum(settings.mediaCaptureType);
1740 #endif
1741 }
1742
1743 bool ArgumentCoder<FileChooserSettings>::decode(Decoder& decoder, FileChooserSettings& settings)
1744 {
1745     if (!decoder.decode(settings.allowsMultipleFiles))
1746         return false;
1747     if (!decoder.decode(settings.acceptMIMETypes))
1748         return false;
1749     if (!decoder.decode(settings.acceptFileExtensions))
1750         return false;
1751     if (!decoder.decode(settings.selectedFiles))
1752         return false;
1753 #if ENABLE(MEDIA_CAPTURE)
1754     if (!decoder.decodeEnum(settings.mediaCaptureType))
1755         return false;
1756 #endif
1757
1758     return true;
1759 }
1760
1761
1762 void ArgumentCoder<GrammarDetail>::encode(Encoder& encoder, const GrammarDetail& detail)
1763 {
1764     encoder << detail.location;
1765     encoder << detail.length;
1766     encoder << detail.guesses;
1767     encoder << detail.userDescription;
1768 }
1769
1770 bool ArgumentCoder<GrammarDetail>::decode(Decoder& decoder, GrammarDetail& detail)
1771 {
1772     if (!decoder.decode(detail.location))
1773         return false;
1774     if (!decoder.decode(detail.length))
1775         return false;
1776     if (!decoder.decode(detail.guesses))
1777         return false;
1778     if (!decoder.decode(detail.userDescription))
1779         return false;
1780
1781     return true;
1782 }
1783
1784 void ArgumentCoder<TextCheckingRequestData>::encode(Encoder& encoder, const TextCheckingRequestData& request)
1785 {
1786     encoder << request.sequence();
1787     encoder << request.text();
1788     encoder << request.mask();
1789     encoder.encodeEnum(request.processType());
1790 }
1791
1792 bool ArgumentCoder<TextCheckingRequestData>::decode(Decoder& decoder, TextCheckingRequestData& request)
1793 {
1794     int sequence;
1795     if (!decoder.decode(sequence))
1796         return false;
1797
1798     String text;
1799     if (!decoder.decode(text))
1800         return false;
1801
1802     TextCheckingTypeMask mask;
1803     if (!decoder.decode(mask))
1804         return false;
1805
1806     TextCheckingProcessType processType;
1807     if (!decoder.decodeEnum(processType))
1808         return false;
1809
1810     request = TextCheckingRequestData(sequence, text, mask, processType);
1811     return true;
1812 }
1813
1814 void ArgumentCoder<TextCheckingResult>::encode(Encoder& encoder, const TextCheckingResult& result)
1815 {
1816     encoder.encodeEnum(result.type);
1817     encoder << result.location;
1818     encoder << result.length;
1819     encoder << result.details;
1820     encoder << result.replacement;
1821 }
1822
1823 bool ArgumentCoder<TextCheckingResult>::decode(Decoder& decoder, TextCheckingResult& result)
1824 {
1825     if (!decoder.decodeEnum(result.type))
1826         return false;
1827     if (!decoder.decode(result.location))
1828         return false;
1829     if (!decoder.decode(result.length))
1830         return false;
1831     if (!decoder.decode(result.details))
1832         return false;
1833     if (!decoder.decode(result.replacement))
1834         return false;
1835     return true;
1836 }
1837
1838 void ArgumentCoder<URL>::encode(Encoder& encoder, const URL& result)
1839 {
1840     encoder << result.string();
1841 }
1842     
1843 bool ArgumentCoder<URL>::decode(Decoder& decoder, URL& result)
1844 {
1845     String urlAsString;
1846     if (!decoder.decode(urlAsString))
1847         return false;
1848     result = URL(ParsedURLString, urlAsString);
1849     return true;
1850 }
1851
1852 void ArgumentCoder<UserStyleSheet>::encode(Encoder& encoder, const UserStyleSheet& userStyleSheet)
1853 {
1854     encoder << userStyleSheet.source();
1855     encoder << userStyleSheet.url();
1856     encoder << userStyleSheet.whitelist();
1857     encoder << userStyleSheet.blacklist();
1858     encoder.encodeEnum(userStyleSheet.injectedFrames());
1859     encoder.encodeEnum(userStyleSheet.level());
1860 }
1861
1862 bool ArgumentCoder<UserStyleSheet>::decode(Decoder& decoder, UserStyleSheet& userStyleSheet)
1863 {
1864     String source;
1865     if (!decoder.decode(source))
1866         return false;
1867
1868     URL url;
1869     if (!decoder.decode(url))
1870         return false;
1871
1872     Vector<String> whitelist;
1873     if (!decoder.decode(whitelist))
1874         return false;
1875
1876     Vector<String> blacklist;
1877     if (!decoder.decode(blacklist))
1878         return false;
1879
1880     UserContentInjectedFrames injectedFrames;
1881     if (!decoder.decodeEnum(injectedFrames))
1882         return false;
1883
1884     UserStyleLevel level;
1885     if (!decoder.decodeEnum(level))
1886         return false;
1887
1888     userStyleSheet = UserStyleSheet(source, url, WTFMove(whitelist), WTFMove(blacklist), injectedFrames, level);
1889     return true;
1890 }
1891
1892 #if ENABLE(MEDIA_SESSION)
1893 void ArgumentCoder<MediaSessionMetadata>::encode(Encoder& encoder, const MediaSessionMetadata& result)
1894 {
1895     encoder << result.artist();
1896     encoder << result.album();
1897     encoder << result.title();
1898     encoder << result.artworkURL();
1899 }
1900
1901 bool ArgumentCoder<MediaSessionMetadata>::decode(Decoder& decoder, MediaSessionMetadata& result)
1902 {
1903     String artist, album, title;
1904     URL artworkURL;
1905     if (!decoder.decode(artist))
1906         return false;
1907     if (!decoder.decode(album))
1908         return false;
1909     if (!decoder.decode(title))
1910         return false;
1911     if (!decoder.decode(artworkURL))
1912         return false;
1913     result = MediaSessionMetadata(title, artist, album, artworkURL);
1914     return true;
1915 }
1916 #endif
1917
1918 void ArgumentCoder<ScrollableAreaParameters>::encode(Encoder& encoder, const ScrollableAreaParameters& parameters)
1919 {
1920     encoder.encodeEnum(parameters.horizontalScrollElasticity);
1921     encoder.encodeEnum(parameters.verticalScrollElasticity);
1922
1923     encoder.encodeEnum(parameters.horizontalScrollbarMode);
1924     encoder.encodeEnum(parameters.verticalScrollbarMode);
1925
1926     encoder << parameters.hasEnabledHorizontalScrollbar;
1927     encoder << parameters.hasEnabledVerticalScrollbar;
1928 }
1929
1930 bool ArgumentCoder<ScrollableAreaParameters>::decode(Decoder& decoder, ScrollableAreaParameters& params)
1931 {
1932     if (!decoder.decodeEnum(params.horizontalScrollElasticity))
1933         return false;
1934     if (!decoder.decodeEnum(params.verticalScrollElasticity))
1935         return false;
1936
1937     if (!decoder.decodeEnum(params.horizontalScrollbarMode))
1938         return false;
1939     if (!decoder.decodeEnum(params.verticalScrollbarMode))
1940         return false;
1941
1942     if (!decoder.decode(params.hasEnabledHorizontalScrollbar))
1943         return false;
1944     if (!decoder.decode(params.hasEnabledVerticalScrollbar))
1945         return false;
1946     
1947     return true;
1948 }
1949
1950 void ArgumentCoder<FixedPositionViewportConstraints>::encode(Encoder& encoder, const FixedPositionViewportConstraints& viewportConstraints)
1951 {
1952     encoder << viewportConstraints.alignmentOffset();
1953     encoder << viewportConstraints.anchorEdges();
1954
1955     encoder << viewportConstraints.viewportRectAtLastLayout();
1956     encoder << viewportConstraints.layerPositionAtLastLayout();
1957 }
1958
1959 bool ArgumentCoder<FixedPositionViewportConstraints>::decode(Decoder& decoder, FixedPositionViewportConstraints& viewportConstraints)
1960 {
1961     FloatSize alignmentOffset;
1962     if (!decoder.decode(alignmentOffset))
1963         return false;
1964     
1965     ViewportConstraints::AnchorEdges anchorEdges;
1966     if (!decoder.decode(anchorEdges))
1967         return false;
1968
1969     FloatRect viewportRectAtLastLayout;
1970     if (!decoder.decode(viewportRectAtLastLayout))
1971         return false;
1972
1973     FloatPoint layerPositionAtLastLayout;
1974     if (!decoder.decode(layerPositionAtLastLayout))
1975         return false;
1976
1977     viewportConstraints = FixedPositionViewportConstraints();
1978     viewportConstraints.setAlignmentOffset(alignmentOffset);
1979     viewportConstraints.setAnchorEdges(anchorEdges);
1980
1981     viewportConstraints.setViewportRectAtLastLayout(viewportRectAtLastLayout);
1982     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
1983     
1984     return true;
1985 }
1986
1987 void ArgumentCoder<StickyPositionViewportConstraints>::encode(Encoder& encoder, const StickyPositionViewportConstraints& viewportConstraints)
1988 {
1989     encoder << viewportConstraints.alignmentOffset();
1990     encoder << viewportConstraints.anchorEdges();
1991
1992     encoder << viewportConstraints.leftOffset();
1993     encoder << viewportConstraints.rightOffset();
1994     encoder << viewportConstraints.topOffset();
1995     encoder << viewportConstraints.bottomOffset();
1996
1997     encoder << viewportConstraints.constrainingRectAtLastLayout();
1998     encoder << viewportConstraints.containingBlockRect();
1999     encoder << viewportConstraints.stickyBoxRect();
2000
2001     encoder << viewportConstraints.stickyOffsetAtLastLayout();
2002     encoder << viewportConstraints.layerPositionAtLastLayout();
2003 }
2004
2005 bool ArgumentCoder<StickyPositionViewportConstraints>::decode(Decoder& decoder, StickyPositionViewportConstraints& viewportConstraints)
2006 {
2007     FloatSize alignmentOffset;
2008     if (!decoder.decode(alignmentOffset))
2009         return false;
2010     
2011     ViewportConstraints::AnchorEdges anchorEdges;
2012     if (!decoder.decode(anchorEdges))
2013         return false;
2014     
2015     float leftOffset;
2016     if (!decoder.decode(leftOffset))
2017         return false;
2018
2019     float rightOffset;
2020     if (!decoder.decode(rightOffset))
2021         return false;
2022
2023     float topOffset;
2024     if (!decoder.decode(topOffset))
2025         return false;
2026
2027     float bottomOffset;
2028     if (!decoder.decode(bottomOffset))
2029         return false;
2030     
2031     FloatRect constrainingRectAtLastLayout;
2032     if (!decoder.decode(constrainingRectAtLastLayout))
2033         return false;
2034
2035     FloatRect containingBlockRect;
2036     if (!decoder.decode(containingBlockRect))
2037         return false;
2038
2039     FloatRect stickyBoxRect;
2040     if (!decoder.decode(stickyBoxRect))
2041         return false;
2042
2043     FloatSize stickyOffsetAtLastLayout;
2044     if (!decoder.decode(stickyOffsetAtLastLayout))
2045         return false;
2046     
2047     FloatPoint layerPositionAtLastLayout;
2048     if (!decoder.decode(layerPositionAtLastLayout))
2049         return false;
2050     
2051     viewportConstraints = StickyPositionViewportConstraints();
2052     viewportConstraints.setAlignmentOffset(alignmentOffset);
2053     viewportConstraints.setAnchorEdges(anchorEdges);
2054
2055     viewportConstraints.setLeftOffset(leftOffset);
2056     viewportConstraints.setRightOffset(rightOffset);
2057     viewportConstraints.setTopOffset(topOffset);
2058     viewportConstraints.setBottomOffset(bottomOffset);
2059     
2060     viewportConstraints.setConstrainingRectAtLastLayout(constrainingRectAtLastLayout);
2061     viewportConstraints.setContainingBlockRect(containingBlockRect);
2062     viewportConstraints.setStickyBoxRect(stickyBoxRect);
2063
2064     viewportConstraints.setStickyOffsetAtLastLayout(stickyOffsetAtLastLayout);
2065     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
2066
2067     return true;
2068 }
2069
2070 #if !USE(COORDINATED_GRAPHICS)
2071 void ArgumentCoder<FilterOperation>::encode(Encoder& encoder, const FilterOperation& filter)
2072 {
2073     encoder.encodeEnum(filter.type());
2074
2075     switch (filter.type()) {
2076     case FilterOperation::NONE:
2077     case FilterOperation::REFERENCE:
2078         ASSERT_NOT_REACHED();
2079         break;
2080     case FilterOperation::GRAYSCALE:
2081     case FilterOperation::SEPIA:
2082     case FilterOperation::SATURATE:
2083     case FilterOperation::HUE_ROTATE:
2084         encoder << downcast<BasicColorMatrixFilterOperation>(filter).amount();
2085         break;
2086     case FilterOperation::INVERT:
2087     case FilterOperation::OPACITY:
2088     case FilterOperation::BRIGHTNESS:
2089     case FilterOperation::CONTRAST:
2090         encoder << downcast<BasicComponentTransferFilterOperation>(filter).amount();
2091         break;
2092     case FilterOperation::BLUR:
2093         encoder << downcast<BlurFilterOperation>(filter).stdDeviation();
2094         break;
2095     case FilterOperation::DROP_SHADOW: {
2096         const auto& dropShadowFilter = downcast<DropShadowFilterOperation>(filter);
2097         encoder << dropShadowFilter.location();
2098         encoder << dropShadowFilter.stdDeviation();
2099         encoder << dropShadowFilter.color();
2100         break;
2101     }
2102     case FilterOperation::DEFAULT:
2103         encoder.encodeEnum(downcast<DefaultFilterOperation>(filter).representedType());
2104         break;
2105     case FilterOperation::PASSTHROUGH:
2106         break;
2107     }
2108 }
2109
2110 bool decodeFilterOperation(Decoder& decoder, RefPtr<FilterOperation>& filter)
2111 {
2112     FilterOperation::OperationType type;
2113     if (!decoder.decodeEnum(type))
2114         return false;
2115
2116     switch (type) {
2117     case FilterOperation::NONE:
2118     case FilterOperation::REFERENCE:
2119         ASSERT_NOT_REACHED();
2120         decoder.markInvalid();
2121         return false;
2122     case FilterOperation::GRAYSCALE:
2123     case FilterOperation::SEPIA:
2124     case FilterOperation::SATURATE:
2125     case FilterOperation::HUE_ROTATE: {
2126         double amount;
2127         if (!decoder.decode(amount))
2128             return false;
2129         filter = BasicColorMatrixFilterOperation::create(amount, type);
2130         break;
2131     }
2132     case FilterOperation::INVERT:
2133     case FilterOperation::OPACITY:
2134     case FilterOperation::BRIGHTNESS:
2135     case FilterOperation::CONTRAST: {
2136         double amount;
2137         if (!decoder.decode(amount))
2138             return false;
2139         filter = BasicComponentTransferFilterOperation::create(amount, type);
2140         break;
2141     }
2142     case FilterOperation::BLUR: {
2143         Length stdDeviation;
2144         if (!decoder.decode(stdDeviation))
2145             return false;
2146         filter = BlurFilterOperation::create(stdDeviation);
2147         break;
2148     }
2149     case FilterOperation::DROP_SHADOW: {
2150         IntPoint location;
2151         int stdDeviation;
2152         Color color;
2153         if (!decoder.decode(location))
2154             return false;
2155         if (!decoder.decode(stdDeviation))
2156             return false;
2157         if (!decoder.decode(color))
2158             return false;
2159         filter = DropShadowFilterOperation::create(location, stdDeviation, color);
2160         break;
2161     }
2162     case FilterOperation::DEFAULT: {
2163         FilterOperation::OperationType representedType;
2164         if (!decoder.decodeEnum(representedType))
2165             return false;
2166         filter = DefaultFilterOperation::create(representedType);
2167         break;
2168     }
2169     case FilterOperation::PASSTHROUGH:
2170         filter = PassthroughFilterOperation::create();
2171         break;
2172     }
2173             
2174     return true;
2175 }
2176
2177
2178 void ArgumentCoder<FilterOperations>::encode(Encoder& encoder, const FilterOperations& filters)
2179 {
2180     encoder << static_cast<uint64_t>(filters.size());
2181
2182     for (const auto& filter : filters.operations())
2183         encoder << *filter;
2184 }
2185
2186 bool ArgumentCoder<FilterOperations>::decode(Decoder& decoder, FilterOperations& filters)
2187 {
2188     uint64_t filterCount;
2189     if (!decoder.decode(filterCount))
2190         return false;
2191
2192     for (uint64_t i = 0; i < filterCount; ++i) {
2193         RefPtr<FilterOperation> filter;
2194         if (!decodeFilterOperation(decoder, filter))
2195             return false;
2196         filters.operations().append(WTFMove(filter));
2197     }
2198
2199     return true;
2200 }
2201 #endif // !USE(COORDINATED_GRAPHICS)
2202
2203 void ArgumentCoder<BlobPart>::encode(Encoder& encoder, const BlobPart& blobPart)
2204 {
2205     encoder << static_cast<uint32_t>(blobPart.type());
2206     switch (blobPart.type()) {
2207     case BlobPart::Data:
2208         encoder << blobPart.data();
2209         break;
2210     case BlobPart::Blob:
2211         encoder << blobPart.url();
2212         break;
2213     }
2214 }
2215
2216 bool ArgumentCoder<BlobPart>::decode(Decoder& decoder, BlobPart& blobPart)
2217 {
2218     uint32_t type;
2219     if (!decoder.decode(type))
2220         return false;
2221
2222     switch (type) {
2223     case BlobPart::Data: {
2224         Vector<uint8_t> data;
2225         if (!decoder.decode(data))
2226             return false;
2227         blobPart = BlobPart(WTFMove(data));
2228         break;
2229     }
2230     case BlobPart::Blob: {
2231         URL url;
2232         if (!decoder.decode(url))
2233             return false;
2234         blobPart = BlobPart(url);
2235         break;
2236     }
2237     default:
2238         return false;
2239     }
2240
2241     return true;
2242 }
2243
2244 void ArgumentCoder<TextIndicatorData>::encode(Encoder& encoder, const TextIndicatorData& textIndicatorData)
2245 {
2246     encoder << textIndicatorData.selectionRectInRootViewCoordinates;
2247     encoder << textIndicatorData.textBoundingRectInRootViewCoordinates;
2248     encoder << textIndicatorData.textRectsInBoundingRectCoordinates;
2249     encoder << textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates;
2250     encoder << textIndicatorData.contentImageScaleFactor;
2251     encoder << textIndicatorData.estimatedBackgroundColor;
2252     encoder.encodeEnum(textIndicatorData.presentationTransition);
2253     encoder << static_cast<uint64_t>(textIndicatorData.options);
2254
2255     encodeOptionalImage(encoder, textIndicatorData.contentImage.get());
2256     encodeOptionalImage(encoder, textIndicatorData.contentImageWithHighlight.get());
2257     encodeOptionalImage(encoder, textIndicatorData.contentImageWithoutSelection.get());
2258 }
2259
2260 bool ArgumentCoder<TextIndicatorData>::decode(Decoder& decoder, TextIndicatorData& textIndicatorData)
2261 {
2262     if (!decoder.decode(textIndicatorData.selectionRectInRootViewCoordinates))
2263         return false;
2264
2265     if (!decoder.decode(textIndicatorData.textBoundingRectInRootViewCoordinates))
2266         return false;
2267
2268     if (!decoder.decode(textIndicatorData.textRectsInBoundingRectCoordinates))
2269         return false;
2270
2271     if (!decoder.decode(textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates))
2272         return false;
2273
2274     if (!decoder.decode(textIndicatorData.contentImageScaleFactor))
2275         return false;
2276
2277     if (!decoder.decode(textIndicatorData.estimatedBackgroundColor))
2278         return false;
2279
2280     if (!decoder.decodeEnum(textIndicatorData.presentationTransition))
2281         return false;
2282
2283     uint64_t options;
2284     if (!decoder.decode(options))
2285         return false;
2286     textIndicatorData.options = static_cast<TextIndicatorOptions>(options);
2287
2288     if (!decodeOptionalImage(decoder, textIndicatorData.contentImage))
2289         return false;
2290
2291     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithHighlight))
2292         return false;
2293
2294     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithoutSelection))
2295         return false;
2296
2297     return true;
2298 }
2299
2300 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
2301 void ArgumentCoder<MediaPlaybackTargetContext>::encode(Encoder& encoder, const MediaPlaybackTargetContext& target)
2302 {
2303     bool hasPlatformData = target.encodingRequiresPlatformData();
2304     encoder << hasPlatformData;
2305
2306     int32_t targetType = target.type();
2307     encoder << targetType;
2308
2309     if (target.encodingRequiresPlatformData()) {
2310         encodePlatformData(encoder, target);
2311         return;
2312     }
2313
2314     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2315     encoder << target.mockDeviceName();
2316     encoder << static_cast<int32_t>(target.mockState());
2317 }
2318
2319 bool ArgumentCoder<MediaPlaybackTargetContext>::decode(Decoder& decoder, MediaPlaybackTargetContext& target)
2320 {
2321     bool hasPlatformData;
2322     if (!decoder.decode(hasPlatformData))
2323         return false;
2324
2325     int32_t targetType;
2326     if (!decoder.decode(targetType))
2327         return false;
2328
2329     if (hasPlatformData)
2330         return decodePlatformData(decoder, target);
2331
2332     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2333
2334     String mockDeviceName;
2335     if (!decoder.decode(mockDeviceName))
2336         return false;
2337
2338     int32_t mockState;
2339     if (!decoder.decode(mockState))
2340         return false;
2341
2342     target = MediaPlaybackTargetContext(mockDeviceName, static_cast<MediaPlaybackTargetContext::State>(mockState));
2343     return true;
2344 }
2345 #endif
2346
2347 void ArgumentCoder<DictionaryPopupInfo>::encode(IPC::Encoder& encoder, const DictionaryPopupInfo& info)
2348 {
2349     encoder << info.origin;
2350     encoder << info.textIndicator;
2351
2352 #if PLATFORM(COCOA)
2353     bool hadOptions = info.options;
2354     encoder << hadOptions;
2355     if (hadOptions)
2356         IPC::encode(encoder, info.options.get());
2357
2358     bool hadAttributedString = info.attributedString;
2359     encoder << hadAttributedString;
2360     if (hadAttributedString)
2361         IPC::encode(encoder, info.attributedString.get());
2362 #endif
2363 }
2364
2365 bool ArgumentCoder<DictionaryPopupInfo>::decode(IPC::Decoder& decoder, DictionaryPopupInfo& result)
2366 {
2367     if (!decoder.decode(result.origin))
2368         return false;
2369
2370     if (!decoder.decode(result.textIndicator))
2371         return false;
2372
2373 #if PLATFORM(COCOA)
2374     bool hadOptions;
2375     if (!decoder.decode(hadOptions))
2376         return false;
2377     if (hadOptions) {
2378         if (!IPC::decode(decoder, result.options))
2379             return false;
2380     } else
2381         result.options = nullptr;
2382
2383     bool hadAttributedString;
2384     if (!decoder.decode(hadAttributedString))
2385         return false;
2386     if (hadAttributedString) {
2387         if (!IPC::decode(decoder, result.attributedString))
2388             return false;
2389     } else
2390         result.attributedString = nullptr;
2391 #endif
2392     return true;
2393 }
2394
2395 void ArgumentCoder<ExceptionDetails>::encode(IPC::Encoder& encoder, const ExceptionDetails& info)
2396 {
2397     encoder << info.message;
2398     encoder << info.lineNumber;
2399     encoder << info.columnNumber;
2400     encoder << info.sourceURL;
2401 }
2402
2403 bool ArgumentCoder<ExceptionDetails>::decode(IPC::Decoder& decoder, ExceptionDetails& result)
2404 {
2405     if (!decoder.decode(result.message))
2406         return false;
2407
2408     if (!decoder.decode(result.lineNumber))
2409         return false;
2410
2411     if (!decoder.decode(result.columnNumber))
2412         return false;
2413
2414     if (!decoder.decode(result.sourceURL))
2415         return false;
2416
2417     return true;
2418 }
2419
2420 void ArgumentCoder<ResourceLoadStatistics>::encode(Encoder& encoder, const WebCore::ResourceLoadStatistics& statistics)
2421 {
2422     encoder << statistics.highLevelDomain;
2423     
2424     encoder << statistics.lastSeen.secondsSinceEpoch().value();
2425     
2426     // User interaction
2427     encoder << statistics.hadUserInteraction;
2428     encoder << statistics.mostRecentUserInteractionTime.secondsSinceEpoch().value();
2429     encoder << statistics.grandfathered;
2430     
2431     // Subframe stats
2432     encoder << statistics.subframeUnderTopFrameOrigins;
2433     
2434     // Subresource stats
2435     encoder << statistics.subresourceUnderTopFrameOrigins;
2436     encoder << statistics.subresourceUniqueRedirectsTo;
2437     
2438     // Prevalent Resource
2439     encoder << statistics.isPrevalentResource;
2440     encoder << statistics.dataRecordsRemoved;
2441 }
2442
2443 bool ArgumentCoder<ResourceLoadStatistics>::decode(Decoder& decoder, WebCore::ResourceLoadStatistics& statistics)
2444 {
2445     if (!decoder.decode(statistics.highLevelDomain))
2446         return false;
2447     
2448     double lastSeenTimeAsDouble;
2449     if (!decoder.decode(lastSeenTimeAsDouble))
2450         return false;
2451     statistics.lastSeen = WallTime::fromRawSeconds(lastSeenTimeAsDouble);
2452     
2453     // User interaction
2454     if (!decoder.decode(statistics.hadUserInteraction))
2455         return false;
2456
2457     double mostRecentUserInteractionTimeAsDouble;
2458     if (!decoder.decode(mostRecentUserInteractionTimeAsDouble))
2459         return false;
2460     statistics.mostRecentUserInteractionTime = WallTime::fromRawSeconds(mostRecentUserInteractionTimeAsDouble);
2461
2462     if (!decoder.decode(statistics.grandfathered))
2463         return false;
2464     
2465     // Subframe stats
2466     if (!decoder.decode(statistics.subframeUnderTopFrameOrigins))
2467         return false;
2468     
2469     // Subresource stats
2470     if (!decoder.decode(statistics.subresourceUnderTopFrameOrigins))
2471         return false;
2472
2473     if (!decoder.decode(statistics.subresourceUniqueRedirectsTo))
2474         return false;
2475     
2476     // Prevalent Resource
2477     if (!decoder.decode(statistics.isPrevalentResource))
2478         return false;
2479
2480     if (!decoder.decode(statistics.dataRecordsRemoved))
2481         return false;
2482
2483     return true;
2484 }
2485
2486 #if ENABLE(MEDIA_STREAM)
2487 void ArgumentCoder<MediaConstraints>::encode(Encoder& encoder, const WebCore::MediaConstraints& constraint)
2488 {
2489     encoder << constraint.mandatoryConstraints
2490         << constraint.advancedConstraints
2491         << constraint.deviceIDHashSalt
2492         << constraint.isValid;
2493 }
2494
2495 bool ArgumentCoder<MediaConstraints>::decode(Decoder& decoder, WebCore::MediaConstraints& constraints)
2496 {
2497     return decoder.decode(constraints.mandatoryConstraints)
2498         && decoder.decode(constraints.advancedConstraints)
2499         && decoder.decode(constraints.deviceIDHashSalt)
2500         && decoder.decode(constraints.isValid);
2501 }
2502
2503 void ArgumentCoder<CaptureDevice>::encode(Encoder& encoder, const WebCore::CaptureDevice& device)
2504 {
2505     encoder << device.persistentId();
2506     encoder << device.label();
2507     encoder << device.groupId();
2508     encoder << device.enabled();
2509     encoder.encodeEnum(device.type());
2510 }
2511
2512 bool ArgumentCoder<CaptureDevice>::decode(Decoder& decoder, WebCore::CaptureDevice& device)
2513 {
2514     String persistentId;
2515     if (!decoder.decode(persistentId))
2516         return false;
2517
2518     String label;
2519     if (!decoder.decode(label))
2520         return false;
2521
2522     String groupId;
2523     if (!decoder.decode(groupId))
2524         return false;
2525
2526     bool enabled;
2527     if (!decoder.decode(enabled))
2528         return false;
2529
2530     CaptureDevice::DeviceType type;
2531     if (!decoder.decodeEnum(type))
2532         return false;
2533
2534     device.setPersistentId(persistentId);
2535     device.setLabel(label);
2536     device.setGroupId(groupId);
2537     device.setType(type);
2538     device.setEnabled(enabled);
2539
2540     return true;
2541 }
2542 #endif
2543
2544 #if ENABLE(INDEXED_DATABASE)
2545 void ArgumentCoder<IDBKeyPath>::encode(Encoder& encoder, const IDBKeyPath& keyPath)
2546 {
2547     bool isString = WTF::holds_alternative<String>(keyPath);
2548     encoder << isString;
2549     if (isString)
2550         encoder << WTF::get<String>(keyPath);
2551     else
2552         encoder << WTF::get<Vector<String>>(keyPath);
2553 }
2554
2555 bool ArgumentCoder<IDBKeyPath>::decode(Decoder& decoder, IDBKeyPath& keyPath)
2556 {
2557     bool isString;
2558     if (!decoder.decode(isString))
2559         return false;
2560     if (isString) {
2561         String string;
2562         if (!decoder.decode(string))
2563             return false;
2564         keyPath = string;
2565     } else {
2566         Vector<String> vector;
2567         if (!decoder.decode(vector))
2568             return false;
2569         keyPath = vector;
2570     }
2571     return true;
2572 }
2573 #endif
2574
2575 #if ENABLE(CSS_SCROLL_SNAP)
2576
2577 void ArgumentCoder<ScrollOffsetRange<float>>::encode(Encoder& encoder, const ScrollOffsetRange<float>& range)
2578 {
2579     encoder << range.start;
2580     encoder << range.end;
2581 }
2582
2583 bool ArgumentCoder<ScrollOffsetRange<float>>::decode(Decoder& decoder, ScrollOffsetRange<float>& range)
2584 {
2585     float start;
2586     if (!decoder.decode(start))
2587         return false;
2588
2589     float end;
2590     if (!decoder.decode(end))
2591         return false;
2592
2593     range.start = start;
2594     range.end = end;
2595     return true;
2596 }
2597
2598 #endif
2599
2600 void ArgumentCoder<MediaSelectionOption>::encode(Encoder& encoder, const MediaSelectionOption& option)
2601 {
2602     encoder << option.displayName;
2603     encoder << option.type;
2604 }
2605
2606 bool ArgumentCoder<MediaSelectionOption>::decode(Decoder& decoder, MediaSelectionOption& option)
2607 {
2608     if (!decoder.decode(option.displayName))
2609         return false;
2610
2611     if (!decoder.decode(option.type))
2612         return false;
2613
2614     return true;
2615 }
2616
2617 } // namespace IPC