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