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