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