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