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