[Directory Upload] Add basic support for input.webkitdirectory
[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.allowsDirectories;
1716     encoder << settings.allowsMultipleFiles;
1717     encoder << settings.acceptMIMETypes;
1718     encoder << settings.acceptFileExtensions;
1719     encoder << settings.selectedFiles;
1720 #if ENABLE(MEDIA_CAPTURE)
1721     encoder.encodeEnum(settings.mediaCaptureType);
1722 #endif
1723 }
1724
1725 bool ArgumentCoder<FileChooserSettings>::decode(Decoder& decoder, FileChooserSettings& settings)
1726 {
1727     if (!decoder.decode(settings.allowsDirectories))
1728         return false;
1729     if (!decoder.decode(settings.allowsMultipleFiles))
1730         return false;
1731     if (!decoder.decode(settings.acceptMIMETypes))
1732         return false;
1733     if (!decoder.decode(settings.acceptFileExtensions))
1734         return false;
1735     if (!decoder.decode(settings.selectedFiles))
1736         return false;
1737 #if ENABLE(MEDIA_CAPTURE)
1738     if (!decoder.decodeEnum(settings.mediaCaptureType))
1739         return false;
1740 #endif
1741
1742     return true;
1743 }
1744
1745
1746 void ArgumentCoder<GrammarDetail>::encode(Encoder& encoder, const GrammarDetail& detail)
1747 {
1748     encoder << detail.location;
1749     encoder << detail.length;
1750     encoder << detail.guesses;
1751     encoder << detail.userDescription;
1752 }
1753
1754 bool ArgumentCoder<GrammarDetail>::decode(Decoder& decoder, GrammarDetail& detail)
1755 {
1756     if (!decoder.decode(detail.location))
1757         return false;
1758     if (!decoder.decode(detail.length))
1759         return false;
1760     if (!decoder.decode(detail.guesses))
1761         return false;
1762     if (!decoder.decode(detail.userDescription))
1763         return false;
1764
1765     return true;
1766 }
1767
1768 void ArgumentCoder<TextCheckingRequestData>::encode(Encoder& encoder, const TextCheckingRequestData& request)
1769 {
1770     encoder << request.sequence();
1771     encoder << request.text();
1772     encoder << request.mask();
1773     encoder.encodeEnum(request.processType());
1774 }
1775
1776 bool ArgumentCoder<TextCheckingRequestData>::decode(Decoder& decoder, TextCheckingRequestData& request)
1777 {
1778     int sequence;
1779     if (!decoder.decode(sequence))
1780         return false;
1781
1782     String text;
1783     if (!decoder.decode(text))
1784         return false;
1785
1786     TextCheckingTypeMask mask;
1787     if (!decoder.decode(mask))
1788         return false;
1789
1790     TextCheckingProcessType processType;
1791     if (!decoder.decodeEnum(processType))
1792         return false;
1793
1794     request = TextCheckingRequestData(sequence, text, mask, processType);
1795     return true;
1796 }
1797
1798 void ArgumentCoder<TextCheckingResult>::encode(Encoder& encoder, const TextCheckingResult& result)
1799 {
1800     encoder.encodeEnum(result.type);
1801     encoder << result.location;
1802     encoder << result.length;
1803     encoder << result.details;
1804     encoder << result.replacement;
1805 }
1806
1807 bool ArgumentCoder<TextCheckingResult>::decode(Decoder& decoder, TextCheckingResult& result)
1808 {
1809     if (!decoder.decodeEnum(result.type))
1810         return false;
1811     if (!decoder.decode(result.location))
1812         return false;
1813     if (!decoder.decode(result.length))
1814         return false;
1815     if (!decoder.decode(result.details))
1816         return false;
1817     if (!decoder.decode(result.replacement))
1818         return false;
1819     return true;
1820 }
1821
1822 void ArgumentCoder<UserStyleSheet>::encode(Encoder& encoder, const UserStyleSheet& userStyleSheet)
1823 {
1824     encoder << userStyleSheet.source();
1825     encoder << userStyleSheet.url();
1826     encoder << userStyleSheet.whitelist();
1827     encoder << userStyleSheet.blacklist();
1828     encoder.encodeEnum(userStyleSheet.injectedFrames());
1829     encoder.encodeEnum(userStyleSheet.level());
1830 }
1831
1832 bool ArgumentCoder<UserStyleSheet>::decode(Decoder& decoder, UserStyleSheet& userStyleSheet)
1833 {
1834     String source;
1835     if (!decoder.decode(source))
1836         return false;
1837
1838     URL url;
1839     if (!decoder.decode(url))
1840         return false;
1841
1842     Vector<String> whitelist;
1843     if (!decoder.decode(whitelist))
1844         return false;
1845
1846     Vector<String> blacklist;
1847     if (!decoder.decode(blacklist))
1848         return false;
1849
1850     UserContentInjectedFrames injectedFrames;
1851     if (!decoder.decodeEnum(injectedFrames))
1852         return false;
1853
1854     UserStyleLevel level;
1855     if (!decoder.decodeEnum(level))
1856         return false;
1857
1858     userStyleSheet = UserStyleSheet(source, url, WTFMove(whitelist), WTFMove(blacklist), injectedFrames, level);
1859     return true;
1860 }
1861
1862 #if ENABLE(MEDIA_SESSION)
1863 void ArgumentCoder<MediaSessionMetadata>::encode(Encoder& encoder, const MediaSessionMetadata& result)
1864 {
1865     encoder << result.artist();
1866     encoder << result.album();
1867     encoder << result.title();
1868     encoder << result.artworkURL();
1869 }
1870
1871 bool ArgumentCoder<MediaSessionMetadata>::decode(Decoder& decoder, MediaSessionMetadata& result)
1872 {
1873     String artist, album, title;
1874     URL artworkURL;
1875     if (!decoder.decode(artist))
1876         return false;
1877     if (!decoder.decode(album))
1878         return false;
1879     if (!decoder.decode(title))
1880         return false;
1881     if (!decoder.decode(artworkURL))
1882         return false;
1883     result = MediaSessionMetadata(title, artist, album, artworkURL);
1884     return true;
1885 }
1886 #endif
1887
1888 void ArgumentCoder<ScrollableAreaParameters>::encode(Encoder& encoder, const ScrollableAreaParameters& parameters)
1889 {
1890     encoder.encodeEnum(parameters.horizontalScrollElasticity);
1891     encoder.encodeEnum(parameters.verticalScrollElasticity);
1892
1893     encoder.encodeEnum(parameters.horizontalScrollbarMode);
1894     encoder.encodeEnum(parameters.verticalScrollbarMode);
1895
1896     encoder << parameters.hasEnabledHorizontalScrollbar;
1897     encoder << parameters.hasEnabledVerticalScrollbar;
1898 }
1899
1900 bool ArgumentCoder<ScrollableAreaParameters>::decode(Decoder& decoder, ScrollableAreaParameters& params)
1901 {
1902     if (!decoder.decodeEnum(params.horizontalScrollElasticity))
1903         return false;
1904     if (!decoder.decodeEnum(params.verticalScrollElasticity))
1905         return false;
1906
1907     if (!decoder.decodeEnum(params.horizontalScrollbarMode))
1908         return false;
1909     if (!decoder.decodeEnum(params.verticalScrollbarMode))
1910         return false;
1911
1912     if (!decoder.decode(params.hasEnabledHorizontalScrollbar))
1913         return false;
1914     if (!decoder.decode(params.hasEnabledVerticalScrollbar))
1915         return false;
1916     
1917     return true;
1918 }
1919
1920 void ArgumentCoder<FixedPositionViewportConstraints>::encode(Encoder& encoder, const FixedPositionViewportConstraints& viewportConstraints)
1921 {
1922     encoder << viewportConstraints.alignmentOffset();
1923     encoder << viewportConstraints.anchorEdges();
1924
1925     encoder << viewportConstraints.viewportRectAtLastLayout();
1926     encoder << viewportConstraints.layerPositionAtLastLayout();
1927 }
1928
1929 bool ArgumentCoder<FixedPositionViewportConstraints>::decode(Decoder& decoder, FixedPositionViewportConstraints& viewportConstraints)
1930 {
1931     FloatSize alignmentOffset;
1932     if (!decoder.decode(alignmentOffset))
1933         return false;
1934     
1935     ViewportConstraints::AnchorEdges anchorEdges;
1936     if (!decoder.decode(anchorEdges))
1937         return false;
1938
1939     FloatRect viewportRectAtLastLayout;
1940     if (!decoder.decode(viewportRectAtLastLayout))
1941         return false;
1942
1943     FloatPoint layerPositionAtLastLayout;
1944     if (!decoder.decode(layerPositionAtLastLayout))
1945         return false;
1946
1947     viewportConstraints = FixedPositionViewportConstraints();
1948     viewportConstraints.setAlignmentOffset(alignmentOffset);
1949     viewportConstraints.setAnchorEdges(anchorEdges);
1950
1951     viewportConstraints.setViewportRectAtLastLayout(viewportRectAtLastLayout);
1952     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
1953     
1954     return true;
1955 }
1956
1957 void ArgumentCoder<StickyPositionViewportConstraints>::encode(Encoder& encoder, const StickyPositionViewportConstraints& viewportConstraints)
1958 {
1959     encoder << viewportConstraints.alignmentOffset();
1960     encoder << viewportConstraints.anchorEdges();
1961
1962     encoder << viewportConstraints.leftOffset();
1963     encoder << viewportConstraints.rightOffset();
1964     encoder << viewportConstraints.topOffset();
1965     encoder << viewportConstraints.bottomOffset();
1966
1967     encoder << viewportConstraints.constrainingRectAtLastLayout();
1968     encoder << viewportConstraints.containingBlockRect();
1969     encoder << viewportConstraints.stickyBoxRect();
1970
1971     encoder << viewportConstraints.stickyOffsetAtLastLayout();
1972     encoder << viewportConstraints.layerPositionAtLastLayout();
1973 }
1974
1975 bool ArgumentCoder<StickyPositionViewportConstraints>::decode(Decoder& decoder, StickyPositionViewportConstraints& viewportConstraints)
1976 {
1977     FloatSize alignmentOffset;
1978     if (!decoder.decode(alignmentOffset))
1979         return false;
1980     
1981     ViewportConstraints::AnchorEdges anchorEdges;
1982     if (!decoder.decode(anchorEdges))
1983         return false;
1984     
1985     float leftOffset;
1986     if (!decoder.decode(leftOffset))
1987         return false;
1988
1989     float rightOffset;
1990     if (!decoder.decode(rightOffset))
1991         return false;
1992
1993     float topOffset;
1994     if (!decoder.decode(topOffset))
1995         return false;
1996
1997     float bottomOffset;
1998     if (!decoder.decode(bottomOffset))
1999         return false;
2000     
2001     FloatRect constrainingRectAtLastLayout;
2002     if (!decoder.decode(constrainingRectAtLastLayout))
2003         return false;
2004
2005     FloatRect containingBlockRect;
2006     if (!decoder.decode(containingBlockRect))
2007         return false;
2008
2009     FloatRect stickyBoxRect;
2010     if (!decoder.decode(stickyBoxRect))
2011         return false;
2012
2013     FloatSize stickyOffsetAtLastLayout;
2014     if (!decoder.decode(stickyOffsetAtLastLayout))
2015         return false;
2016     
2017     FloatPoint layerPositionAtLastLayout;
2018     if (!decoder.decode(layerPositionAtLastLayout))
2019         return false;
2020     
2021     viewportConstraints = StickyPositionViewportConstraints();
2022     viewportConstraints.setAlignmentOffset(alignmentOffset);
2023     viewportConstraints.setAnchorEdges(anchorEdges);
2024
2025     viewportConstraints.setLeftOffset(leftOffset);
2026     viewportConstraints.setRightOffset(rightOffset);
2027     viewportConstraints.setTopOffset(topOffset);
2028     viewportConstraints.setBottomOffset(bottomOffset);
2029     
2030     viewportConstraints.setConstrainingRectAtLastLayout(constrainingRectAtLastLayout);
2031     viewportConstraints.setContainingBlockRect(containingBlockRect);
2032     viewportConstraints.setStickyBoxRect(stickyBoxRect);
2033
2034     viewportConstraints.setStickyOffsetAtLastLayout(stickyOffsetAtLastLayout);
2035     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
2036
2037     return true;
2038 }
2039
2040 #if !USE(COORDINATED_GRAPHICS)
2041 void ArgumentCoder<FilterOperation>::encode(Encoder& encoder, const FilterOperation& filter)
2042 {
2043     encoder.encodeEnum(filter.type());
2044
2045     switch (filter.type()) {
2046     case FilterOperation::NONE:
2047     case FilterOperation::REFERENCE:
2048         ASSERT_NOT_REACHED();
2049         break;
2050     case FilterOperation::GRAYSCALE:
2051     case FilterOperation::SEPIA:
2052     case FilterOperation::SATURATE:
2053     case FilterOperation::HUE_ROTATE:
2054         encoder << downcast<BasicColorMatrixFilterOperation>(filter).amount();
2055         break;
2056     case FilterOperation::INVERT:
2057     case FilterOperation::OPACITY:
2058     case FilterOperation::BRIGHTNESS:
2059     case FilterOperation::CONTRAST:
2060         encoder << downcast<BasicComponentTransferFilterOperation>(filter).amount();
2061         break;
2062     case FilterOperation::BLUR:
2063         encoder << downcast<BlurFilterOperation>(filter).stdDeviation();
2064         break;
2065     case FilterOperation::DROP_SHADOW: {
2066         const auto& dropShadowFilter = downcast<DropShadowFilterOperation>(filter);
2067         encoder << dropShadowFilter.location();
2068         encoder << dropShadowFilter.stdDeviation();
2069         encoder << dropShadowFilter.color();
2070         break;
2071     }
2072     case FilterOperation::DEFAULT:
2073         encoder.encodeEnum(downcast<DefaultFilterOperation>(filter).representedType());
2074         break;
2075     case FilterOperation::PASSTHROUGH:
2076         break;
2077     }
2078 }
2079
2080 bool decodeFilterOperation(Decoder& decoder, RefPtr<FilterOperation>& filter)
2081 {
2082     FilterOperation::OperationType type;
2083     if (!decoder.decodeEnum(type))
2084         return false;
2085
2086     switch (type) {
2087     case FilterOperation::NONE:
2088     case FilterOperation::REFERENCE:
2089         ASSERT_NOT_REACHED();
2090         decoder.markInvalid();
2091         return false;
2092     case FilterOperation::GRAYSCALE:
2093     case FilterOperation::SEPIA:
2094     case FilterOperation::SATURATE:
2095     case FilterOperation::HUE_ROTATE: {
2096         double amount;
2097         if (!decoder.decode(amount))
2098             return false;
2099         filter = BasicColorMatrixFilterOperation::create(amount, type);
2100         break;
2101     }
2102     case FilterOperation::INVERT:
2103     case FilterOperation::OPACITY:
2104     case FilterOperation::BRIGHTNESS:
2105     case FilterOperation::CONTRAST: {
2106         double amount;
2107         if (!decoder.decode(amount))
2108             return false;
2109         filter = BasicComponentTransferFilterOperation::create(amount, type);
2110         break;
2111     }
2112     case FilterOperation::BLUR: {
2113         Length stdDeviation;
2114         if (!decoder.decode(stdDeviation))
2115             return false;
2116         filter = BlurFilterOperation::create(stdDeviation);
2117         break;
2118     }
2119     case FilterOperation::DROP_SHADOW: {
2120         IntPoint location;
2121         int stdDeviation;
2122         Color color;
2123         if (!decoder.decode(location))
2124             return false;
2125         if (!decoder.decode(stdDeviation))
2126             return false;
2127         if (!decoder.decode(color))
2128             return false;
2129         filter = DropShadowFilterOperation::create(location, stdDeviation, color);
2130         break;
2131     }
2132     case FilterOperation::DEFAULT: {
2133         FilterOperation::OperationType representedType;
2134         if (!decoder.decodeEnum(representedType))
2135             return false;
2136         filter = DefaultFilterOperation::create(representedType);
2137         break;
2138     }
2139     case FilterOperation::PASSTHROUGH:
2140         filter = PassthroughFilterOperation::create();
2141         break;
2142     }
2143             
2144     return true;
2145 }
2146
2147
2148 void ArgumentCoder<FilterOperations>::encode(Encoder& encoder, const FilterOperations& filters)
2149 {
2150     encoder << static_cast<uint64_t>(filters.size());
2151
2152     for (const auto& filter : filters.operations())
2153         encoder << *filter;
2154 }
2155
2156 bool ArgumentCoder<FilterOperations>::decode(Decoder& decoder, FilterOperations& filters)
2157 {
2158     uint64_t filterCount;
2159     if (!decoder.decode(filterCount))
2160         return false;
2161
2162     for (uint64_t i = 0; i < filterCount; ++i) {
2163         RefPtr<FilterOperation> filter;
2164         if (!decodeFilterOperation(decoder, filter))
2165             return false;
2166         filters.operations().append(WTFMove(filter));
2167     }
2168
2169     return true;
2170 }
2171 #endif // !USE(COORDINATED_GRAPHICS)
2172
2173 void ArgumentCoder<BlobPart>::encode(Encoder& encoder, const BlobPart& blobPart)
2174 {
2175     encoder << static_cast<uint32_t>(blobPart.type());
2176     switch (blobPart.type()) {
2177     case BlobPart::Data:
2178         encoder << blobPart.data();
2179         break;
2180     case BlobPart::Blob:
2181         encoder << blobPart.url();
2182         break;
2183     }
2184 }
2185
2186 bool ArgumentCoder<BlobPart>::decode(Decoder& decoder, BlobPart& blobPart)
2187 {
2188     uint32_t type;
2189     if (!decoder.decode(type))
2190         return false;
2191
2192     switch (type) {
2193     case BlobPart::Data: {
2194         Vector<uint8_t> data;
2195         if (!decoder.decode(data))
2196             return false;
2197         blobPart = BlobPart(WTFMove(data));
2198         break;
2199     }
2200     case BlobPart::Blob: {
2201         URL url;
2202         if (!decoder.decode(url))
2203             return false;
2204         blobPart = BlobPart(url);
2205         break;
2206     }
2207     default:
2208         return false;
2209     }
2210
2211     return true;
2212 }
2213
2214 void ArgumentCoder<TextIndicatorData>::encode(Encoder& encoder, const TextIndicatorData& textIndicatorData)
2215 {
2216     encoder << textIndicatorData.selectionRectInRootViewCoordinates;
2217     encoder << textIndicatorData.textBoundingRectInRootViewCoordinates;
2218     encoder << textIndicatorData.textRectsInBoundingRectCoordinates;
2219     encoder << textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates;
2220     encoder << textIndicatorData.contentImageScaleFactor;
2221     encoder << textIndicatorData.estimatedBackgroundColor;
2222     encoder.encodeEnum(textIndicatorData.presentationTransition);
2223     encoder << static_cast<uint64_t>(textIndicatorData.options);
2224
2225     encodeOptionalImage(encoder, textIndicatorData.contentImage.get());
2226     encodeOptionalImage(encoder, textIndicatorData.contentImageWithHighlight.get());
2227     encodeOptionalImage(encoder, textIndicatorData.contentImageWithoutSelection.get());
2228 }
2229
2230 bool ArgumentCoder<TextIndicatorData>::decode(Decoder& decoder, TextIndicatorData& textIndicatorData)
2231 {
2232     if (!decoder.decode(textIndicatorData.selectionRectInRootViewCoordinates))
2233         return false;
2234
2235     if (!decoder.decode(textIndicatorData.textBoundingRectInRootViewCoordinates))
2236         return false;
2237
2238     if (!decoder.decode(textIndicatorData.textRectsInBoundingRectCoordinates))
2239         return false;
2240
2241     if (!decoder.decode(textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates))
2242         return false;
2243
2244     if (!decoder.decode(textIndicatorData.contentImageScaleFactor))
2245         return false;
2246
2247     if (!decoder.decode(textIndicatorData.estimatedBackgroundColor))
2248         return false;
2249
2250     if (!decoder.decodeEnum(textIndicatorData.presentationTransition))
2251         return false;
2252
2253     uint64_t options;
2254     if (!decoder.decode(options))
2255         return false;
2256     textIndicatorData.options = static_cast<TextIndicatorOptions>(options);
2257
2258     if (!decodeOptionalImage(decoder, textIndicatorData.contentImage))
2259         return false;
2260
2261     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithHighlight))
2262         return false;
2263
2264     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithoutSelection))
2265         return false;
2266
2267     return true;
2268 }
2269
2270 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
2271 void ArgumentCoder<MediaPlaybackTargetContext>::encode(Encoder& encoder, const MediaPlaybackTargetContext& target)
2272 {
2273     bool hasPlatformData = target.encodingRequiresPlatformData();
2274     encoder << hasPlatformData;
2275
2276     int32_t targetType = target.type();
2277     encoder << targetType;
2278
2279     if (target.encodingRequiresPlatformData()) {
2280         encodePlatformData(encoder, target);
2281         return;
2282     }
2283
2284     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2285     encoder << target.mockDeviceName();
2286     encoder << static_cast<int32_t>(target.mockState());
2287 }
2288
2289 bool ArgumentCoder<MediaPlaybackTargetContext>::decode(Decoder& decoder, MediaPlaybackTargetContext& target)
2290 {
2291     bool hasPlatformData;
2292     if (!decoder.decode(hasPlatformData))
2293         return false;
2294
2295     int32_t targetType;
2296     if (!decoder.decode(targetType))
2297         return false;
2298
2299     if (hasPlatformData)
2300         return decodePlatformData(decoder, target);
2301
2302     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2303
2304     String mockDeviceName;
2305     if (!decoder.decode(mockDeviceName))
2306         return false;
2307
2308     int32_t mockState;
2309     if (!decoder.decode(mockState))
2310         return false;
2311
2312     target = MediaPlaybackTargetContext(mockDeviceName, static_cast<MediaPlaybackTargetContext::State>(mockState));
2313     return true;
2314 }
2315 #endif
2316
2317 void ArgumentCoder<DictionaryPopupInfo>::encode(IPC::Encoder& encoder, const DictionaryPopupInfo& info)
2318 {
2319     encoder << info.origin;
2320     encoder << info.textIndicator;
2321
2322 #if PLATFORM(COCOA)
2323     bool hadOptions = info.options;
2324     encoder << hadOptions;
2325     if (hadOptions)
2326         IPC::encode(encoder, info.options.get());
2327
2328     bool hadAttributedString = info.attributedString;
2329     encoder << hadAttributedString;
2330     if (hadAttributedString)
2331         IPC::encode(encoder, info.attributedString.get());
2332 #endif
2333 }
2334
2335 bool ArgumentCoder<DictionaryPopupInfo>::decode(IPC::Decoder& decoder, DictionaryPopupInfo& result)
2336 {
2337     if (!decoder.decode(result.origin))
2338         return false;
2339
2340     if (!decoder.decode(result.textIndicator))
2341         return false;
2342
2343 #if PLATFORM(COCOA)
2344     bool hadOptions;
2345     if (!decoder.decode(hadOptions))
2346         return false;
2347     if (hadOptions) {
2348         if (!IPC::decode(decoder, result.options))
2349             return false;
2350     } else
2351         result.options = nullptr;
2352
2353     bool hadAttributedString;
2354     if (!decoder.decode(hadAttributedString))
2355         return false;
2356     if (hadAttributedString) {
2357         if (!IPC::decode(decoder, result.attributedString))
2358             return false;
2359     } else
2360         result.attributedString = nullptr;
2361 #endif
2362     return true;
2363 }
2364
2365 void ArgumentCoder<ExceptionDetails>::encode(IPC::Encoder& encoder, const ExceptionDetails& info)
2366 {
2367     encoder << info.message;
2368     encoder << info.lineNumber;
2369     encoder << info.columnNumber;
2370     encoder << info.sourceURL;
2371 }
2372
2373 bool ArgumentCoder<ExceptionDetails>::decode(IPC::Decoder& decoder, ExceptionDetails& result)
2374 {
2375     if (!decoder.decode(result.message))
2376         return false;
2377
2378     if (!decoder.decode(result.lineNumber))
2379         return false;
2380
2381     if (!decoder.decode(result.columnNumber))
2382         return false;
2383
2384     if (!decoder.decode(result.sourceURL))
2385         return false;
2386
2387     return true;
2388 }
2389
2390 void ArgumentCoder<ResourceLoadStatistics>::encode(Encoder& encoder, const WebCore::ResourceLoadStatistics& statistics)
2391 {
2392     encoder << statistics.highLevelDomain;
2393     
2394     encoder << statistics.lastSeen.secondsSinceEpoch().value();
2395     
2396     // User interaction
2397     encoder << statistics.hadUserInteraction;
2398     encoder << statistics.mostRecentUserInteractionTime.secondsSinceEpoch().value();
2399     encoder << statistics.grandfathered;
2400     
2401     // Subframe stats
2402     encoder << statistics.subframeUnderTopFrameOrigins;
2403     
2404     // Subresource stats
2405     encoder << statistics.subresourceUnderTopFrameOrigins;
2406     encoder << statistics.subresourceUniqueRedirectsTo;
2407     
2408     // Prevalent Resource
2409     encoder << statistics.isPrevalentResource;
2410     encoder << statistics.dataRecordsRemoved;
2411 }
2412
2413 bool ArgumentCoder<ResourceLoadStatistics>::decode(Decoder& decoder, WebCore::ResourceLoadStatistics& statistics)
2414 {
2415     if (!decoder.decode(statistics.highLevelDomain))
2416         return false;
2417     
2418     double lastSeenTimeAsDouble;
2419     if (!decoder.decode(lastSeenTimeAsDouble))
2420         return false;
2421     statistics.lastSeen = WallTime::fromRawSeconds(lastSeenTimeAsDouble);
2422     
2423     // User interaction
2424     if (!decoder.decode(statistics.hadUserInteraction))
2425         return false;
2426
2427     double mostRecentUserInteractionTimeAsDouble;
2428     if (!decoder.decode(mostRecentUserInteractionTimeAsDouble))
2429         return false;
2430     statistics.mostRecentUserInteractionTime = WallTime::fromRawSeconds(mostRecentUserInteractionTimeAsDouble);
2431
2432     if (!decoder.decode(statistics.grandfathered))
2433         return false;
2434     
2435     // Subframe stats
2436     if (!decoder.decode(statistics.subframeUnderTopFrameOrigins))
2437         return false;
2438     
2439     // Subresource stats
2440     if (!decoder.decode(statistics.subresourceUnderTopFrameOrigins))
2441         return false;
2442
2443     if (!decoder.decode(statistics.subresourceUniqueRedirectsTo))
2444         return false;
2445     
2446     // Prevalent Resource
2447     if (!decoder.decode(statistics.isPrevalentResource))
2448         return false;
2449
2450     if (!decoder.decode(statistics.dataRecordsRemoved))
2451         return false;
2452
2453     return true;
2454 }
2455
2456 #if ENABLE(MEDIA_STREAM)
2457 void ArgumentCoder<MediaConstraints>::encode(Encoder& encoder, const WebCore::MediaConstraints& constraint)
2458 {
2459     encoder << constraint.mandatoryConstraints
2460         << constraint.advancedConstraints
2461         << constraint.deviceIDHashSalt
2462         << constraint.isValid;
2463 }
2464
2465 bool ArgumentCoder<MediaConstraints>::decode(Decoder& decoder, WebCore::MediaConstraints& constraints)
2466 {
2467     return decoder.decode(constraints.mandatoryConstraints)
2468         && decoder.decode(constraints.advancedConstraints)
2469         && decoder.decode(constraints.deviceIDHashSalt)
2470         && decoder.decode(constraints.isValid);
2471 }
2472
2473 void ArgumentCoder<CaptureDevice>::encode(Encoder& encoder, const WebCore::CaptureDevice& device)
2474 {
2475     encoder << device.persistentId();
2476     encoder << device.label();
2477     encoder << device.groupId();
2478     encoder << device.enabled();
2479     encoder.encodeEnum(device.type());
2480 }
2481
2482 bool ArgumentCoder<CaptureDevice>::decode(Decoder& decoder, WebCore::CaptureDevice& device)
2483 {
2484     String persistentId;
2485     if (!decoder.decode(persistentId))
2486         return false;
2487
2488     String label;
2489     if (!decoder.decode(label))
2490         return false;
2491
2492     String groupId;
2493     if (!decoder.decode(groupId))
2494         return false;
2495
2496     bool enabled;
2497     if (!decoder.decode(enabled))
2498         return false;
2499
2500     CaptureDevice::DeviceType type;
2501     if (!decoder.decodeEnum(type))
2502         return false;
2503
2504     device.setPersistentId(persistentId);
2505     device.setLabel(label);
2506     device.setGroupId(groupId);
2507     device.setType(type);
2508     device.setEnabled(enabled);
2509
2510     return true;
2511 }
2512 #endif
2513
2514 #if ENABLE(INDEXED_DATABASE)
2515 void ArgumentCoder<IDBKeyPath>::encode(Encoder& encoder, const IDBKeyPath& keyPath)
2516 {
2517     bool isString = WTF::holds_alternative<String>(keyPath);
2518     encoder << isString;
2519     if (isString)
2520         encoder << WTF::get<String>(keyPath);
2521     else
2522         encoder << WTF::get<Vector<String>>(keyPath);
2523 }
2524
2525 bool ArgumentCoder<IDBKeyPath>::decode(Decoder& decoder, IDBKeyPath& keyPath)
2526 {
2527     bool isString;
2528     if (!decoder.decode(isString))
2529         return false;
2530     if (isString) {
2531         String string;
2532         if (!decoder.decode(string))
2533             return false;
2534         keyPath = string;
2535     } else {
2536         Vector<String> vector;
2537         if (!decoder.decode(vector))
2538             return false;
2539         keyPath = vector;
2540     }
2541     return true;
2542 }
2543 #endif
2544
2545 #if ENABLE(CSS_SCROLL_SNAP)
2546
2547 void ArgumentCoder<ScrollOffsetRange<float>>::encode(Encoder& encoder, const ScrollOffsetRange<float>& range)
2548 {
2549     encoder << range.start;
2550     encoder << range.end;
2551 }
2552
2553 bool ArgumentCoder<ScrollOffsetRange<float>>::decode(Decoder& decoder, ScrollOffsetRange<float>& range)
2554 {
2555     float start;
2556     if (!decoder.decode(start))
2557         return false;
2558
2559     float end;
2560     if (!decoder.decode(end))
2561         return false;
2562
2563     range.start = start;
2564     range.end = end;
2565     return true;
2566 }
2567
2568 #endif
2569
2570 void ArgumentCoder<MediaSelectionOption>::encode(Encoder& encoder, const MediaSelectionOption& option)
2571 {
2572     encoder << option.displayName;
2573     encoder << option.type;
2574 }
2575
2576 bool ArgumentCoder<MediaSelectionOption>::decode(Decoder& decoder, MediaSelectionOption& option)
2577 {
2578     if (!decoder.decode(option.displayName))
2579         return false;
2580
2581     if (!decoder.decode(option.type))
2582         return false;
2583
2584     return true;
2585 }
2586
2587 } // namespace IPC