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