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