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