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