Message decoding functions should take a MessageDecoder reference
[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 "ShareableBitmap.h"
30 #include <WebCore/AuthenticationChallenge.h>
31 #include <WebCore/Cookie.h>
32 #include <WebCore/Credential.h>
33 #include <WebCore/Cursor.h>
34 #include <WebCore/DatabaseDetails.h>
35 #include <WebCore/DictationAlternative.h>
36 #include <WebCore/DragSession.h>
37 #include <WebCore/Editor.h>
38 #include <WebCore/FileChooser.h>
39 #include <WebCore/GraphicsContext.h>
40 #include <WebCore/GraphicsLayer.h>
41 #include <WebCore/Image.h>
42 #include <WebCore/KURL.h>
43 #include <WebCore/PluginData.h>
44 #include <WebCore/ProtectionSpace.h>
45 #include <WebCore/ResourceError.h>
46 #include <WebCore/ResourceRequest.h>
47 #include <WebCore/ResourceResponse.h>
48 #include <WebCore/TextCheckerClient.h>
49 #include <WebCore/UserScript.h>
50 #include <WebCore/UserStyleSheet.h>
51 #include <WebCore/ViewportArguments.h>
52 #include <WebCore/WindowFeatures.h>
53 #include <wtf/text/StringHash.h>
54
55 using namespace WebCore;
56 using namespace WebKit;
57
58 namespace CoreIPC {
59
60 void ArgumentCoder<AffineTransform>::encode(ArgumentEncoder& encoder, const AffineTransform& affineTransform)
61 {
62     SimpleArgumentCoder<AffineTransform>::encode(encoder, affineTransform);
63 }
64
65 bool ArgumentCoder<AffineTransform>::decode(ArgumentDecoder& decoder, AffineTransform& affineTransform)
66 {
67     return SimpleArgumentCoder<AffineTransform>::decode(decoder, affineTransform);
68 }
69
70
71 void ArgumentCoder<FloatPoint>::encode(ArgumentEncoder& encoder, const FloatPoint& floatPoint)
72 {
73     SimpleArgumentCoder<FloatPoint>::encode(encoder, floatPoint);
74 }
75
76 bool ArgumentCoder<FloatPoint>::decode(ArgumentDecoder& decoder, FloatPoint& floatPoint)
77 {
78     return SimpleArgumentCoder<FloatPoint>::decode(decoder, floatPoint);
79 }
80
81
82 void ArgumentCoder<FloatRect>::encode(ArgumentEncoder& encoder, const FloatRect& floatRect)
83 {
84     SimpleArgumentCoder<FloatRect>::encode(encoder, floatRect);
85 }
86
87 bool ArgumentCoder<FloatRect>::decode(ArgumentDecoder& decoder, FloatRect& floatRect)
88 {
89     return SimpleArgumentCoder<FloatRect>::decode(decoder, floatRect);
90 }
91
92
93 void ArgumentCoder<FloatSize>::encode(ArgumentEncoder& encoder, const FloatSize& floatSize)
94 {
95     SimpleArgumentCoder<FloatSize>::encode(encoder, floatSize);
96 }
97
98 bool ArgumentCoder<FloatSize>::decode(ArgumentDecoder& decoder, FloatSize& floatSize)
99 {
100     return SimpleArgumentCoder<FloatSize>::decode(decoder, floatSize);
101 }
102
103
104 void ArgumentCoder<IntPoint>::encode(ArgumentEncoder& encoder, const IntPoint& intPoint)
105 {
106     SimpleArgumentCoder<IntPoint>::encode(encoder, intPoint);
107 }
108
109 bool ArgumentCoder<IntPoint>::decode(ArgumentDecoder& decoder, IntPoint& intPoint)
110 {
111     return SimpleArgumentCoder<IntPoint>::decode(decoder, intPoint);
112 }
113
114
115 void ArgumentCoder<IntRect>::encode(ArgumentEncoder& encoder, const IntRect& intRect)
116 {
117     SimpleArgumentCoder<IntRect>::encode(encoder, intRect);
118 }
119
120 bool ArgumentCoder<IntRect>::decode(ArgumentDecoder& decoder, IntRect& intRect)
121 {
122     return SimpleArgumentCoder<IntRect>::decode(decoder, intRect);
123 }
124
125
126 void ArgumentCoder<IntSize>::encode(ArgumentEncoder& encoder, const IntSize& intSize)
127 {
128     SimpleArgumentCoder<IntSize>::encode(encoder, intSize);
129 }
130
131 bool ArgumentCoder<IntSize>::decode(ArgumentDecoder& decoder, IntSize& intSize)
132 {
133     return SimpleArgumentCoder<IntSize>::decode(decoder, intSize);
134 }
135
136
137 void ArgumentCoder<ViewportAttributes>::encode(ArgumentEncoder& encoder, const ViewportAttributes& viewportAttributes)
138 {
139     SimpleArgumentCoder<ViewportAttributes>::encode(encoder, viewportAttributes);
140 }
141
142 bool ArgumentCoder<ViewportAttributes>::decode(ArgumentDecoder& decoder, ViewportAttributes& viewportAttributes)
143 {
144     return SimpleArgumentCoder<ViewportAttributes>::decode(decoder, viewportAttributes);
145 }
146
147
148 void ArgumentCoder<MimeClassInfo>::encode(ArgumentEncoder& encoder, const MimeClassInfo& mimeClassInfo)
149 {
150     encoder << mimeClassInfo.type << mimeClassInfo.desc << mimeClassInfo.extensions;
151 }
152
153 bool ArgumentCoder<MimeClassInfo>::decode(ArgumentDecoder& decoder, MimeClassInfo& mimeClassInfo)
154 {
155     if (!decoder.decode(mimeClassInfo.type))
156         return false;
157     if (!decoder.decode(mimeClassInfo.desc))
158         return false;
159     if (!decoder.decode(mimeClassInfo.extensions))
160         return false;
161
162     return true;
163 }
164
165
166 void ArgumentCoder<PluginInfo>::encode(ArgumentEncoder& encoder, const PluginInfo& pluginInfo)
167 {
168     encoder << pluginInfo.name << pluginInfo.file << pluginInfo.desc << pluginInfo.mimes;
169 }
170     
171 bool ArgumentCoder<PluginInfo>::decode(ArgumentDecoder& decoder, PluginInfo& pluginInfo)
172 {
173     if (!decoder.decode(pluginInfo.name))
174         return false;
175     if (!decoder.decode(pluginInfo.file))
176         return false;
177     if (!decoder.decode(pluginInfo.desc))
178         return false;
179     if (!decoder.decode(pluginInfo.mimes))
180         return false;
181
182     return true;
183 }
184
185
186 void ArgumentCoder<HTTPHeaderMap>::encode(ArgumentEncoder& encoder, const HTTPHeaderMap& headerMap)
187 {
188     encoder << static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap);
189 }
190
191 bool ArgumentCoder<HTTPHeaderMap>::decode(ArgumentDecoder& decoder, HTTPHeaderMap& headerMap)
192 {
193     return decoder.decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
194 }
195
196
197 void ArgumentCoder<AuthenticationChallenge>::encode(ArgumentEncoder& encoder, const AuthenticationChallenge& challenge)
198 {
199     encoder << challenge.protectionSpace() << challenge.proposedCredential() << challenge.previousFailureCount() << challenge.failureResponse() << challenge.error();
200 }
201
202 bool ArgumentCoder<AuthenticationChallenge>::decode(ArgumentDecoder& decoder, AuthenticationChallenge& challenge)
203 {    
204     ProtectionSpace protectionSpace;
205     if (!decoder.decode(protectionSpace))
206         return false;
207
208     Credential proposedCredential;
209     if (!decoder.decode(proposedCredential))
210         return false;
211
212     unsigned previousFailureCount;    
213     if (!decoder.decode(previousFailureCount))
214         return false;
215
216     ResourceResponse failureResponse;
217     if (!decoder.decode(failureResponse))
218         return false;
219
220     ResourceError error;
221     if (!decoder.decode(error))
222         return false;
223     
224     challenge = AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
225     return true;
226 }
227
228
229 void ArgumentCoder<ProtectionSpace>::encode(ArgumentEncoder& encoder, const ProtectionSpace& space)
230 {
231     encoder << space.host() << space.port() << space.realm();
232     encoder.encodeEnum(space.authenticationScheme());
233     encoder.encodeEnum(space.serverType());
234 }
235
236 bool ArgumentCoder<ProtectionSpace>::decode(ArgumentDecoder& decoder, ProtectionSpace& space)
237 {
238     String host;
239     if (!decoder.decode(host))
240         return false;
241
242     int port;
243     if (!decoder.decode(port))
244         return false;
245
246     String realm;
247     if (!decoder.decode(realm))
248         return false;
249     
250     ProtectionSpaceAuthenticationScheme authenticationScheme;
251     if (!decoder.decodeEnum(authenticationScheme))
252         return false;
253
254     ProtectionSpaceServerType serverType;
255     if (!decoder.decodeEnum(serverType))
256         return false;
257
258     space = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
259     return true;
260 }
261
262 void ArgumentCoder<Credential>::encode(ArgumentEncoder& encoder, const Credential& credential)
263 {
264     encoder << credential.user() << credential.password();
265     encoder.encodeEnum(credential.persistence());
266 }
267
268 bool ArgumentCoder<Credential>::decode(ArgumentDecoder& decoder, Credential& credential)
269 {
270     String user;
271     if (!decoder.decode(user))
272         return false;
273
274     String password;
275     if (!decoder.decode(password))
276         return false;
277
278     CredentialPersistence persistence;
279     if (!decoder.decodeEnum(persistence))
280         return false;
281     
282     credential = Credential(user, password, persistence);
283     return true;
284 }
285
286 static void encodeImage(ArgumentEncoder& encoder, Image* image)
287 {
288     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(image->size(), ShareableBitmap::SupportsAlpha);
289     bitmap->createGraphicsContext()->drawImage(image, ColorSpaceDeviceRGB, IntPoint());
290
291     ShareableBitmap::Handle handle;
292     bitmap->createHandle(handle);
293
294     encoder << handle;
295 }
296
297 static bool decodeImage(ArgumentDecoder& decoder, RefPtr<Image>& image)
298 {
299     ShareableBitmap::Handle handle;
300     if (!decoder.decode(handle))
301         return false;
302     
303     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
304     if (!bitmap)
305         return false;
306     image = bitmap->createImage();
307     if (!image)
308         return false;
309     return true;
310 }
311
312 void ArgumentCoder<Cursor>::encode(ArgumentEncoder& encoder, const Cursor& cursor)
313 {
314     encoder.encodeEnum(cursor.type());
315         
316     if (cursor.type() != Cursor::Custom)
317         return;
318
319     if (cursor.image()->isNull()) {
320         encoder << false; // There is no valid image being encoded.
321         return;
322     }
323
324     encoder << true;
325     encodeImage(encoder, cursor.image());
326     encoder << cursor.hotSpot();
327 }
328
329 bool ArgumentCoder<Cursor>::decode(ArgumentDecoder& decoder, Cursor& cursor)
330 {
331     Cursor::Type type;
332     if (!decoder.decodeEnum(type))
333         return false;
334
335     if (type > Cursor::Custom)
336         return false;
337
338     if (type != Cursor::Custom) {
339         const Cursor& cursorReference = Cursor::fromType(type);
340         // Calling platformCursor here will eagerly create the platform cursor for the cursor singletons inside WebCore.
341         // This will avoid having to re-create the platform cursors over and over.
342         (void)cursorReference.platformCursor();
343
344         cursor = cursorReference;
345         return true;
346     }
347
348     bool isValidImagePresent;
349     if (!decoder.decode(isValidImagePresent))
350         return false;
351
352     if (!isValidImagePresent) {
353         cursor = Cursor(Image::nullImage(), IntPoint());
354         return true;
355     }
356
357     RefPtr<Image> image;
358     if (!decodeImage(decoder, image))
359         return false;
360
361     IntPoint hotSpot;
362     if (!decoder.decode(hotSpot))
363         return false;
364
365     if (!image->rect().contains(hotSpot))
366         return false;
367
368     cursor = Cursor(image.get(), hotSpot);
369     return true;
370 }
371
372 void ArgumentCoder<ResourceRequest>::encode(ArgumentEncoder& encoder, const ResourceRequest& resourceRequest)
373 {
374     if (kShouldSerializeWebCoreData) {
375         encoder << resourceRequest.url().string();
376         encoder << resourceRequest.httpMethod();
377         encoder << resourceRequest.httpHeaderFields();
378
379         // FIXME: Do not encode HTTP message body.
380         // 1. It can be large and thus costly to send across.
381         // 2. It is misleading to provide a body with some requests, while others use body streams, which cannot be serialized at all.
382         FormData* httpBody = resourceRequest.httpBody();
383         encoder << static_cast<bool>(httpBody);
384         if (httpBody)
385             encoder << httpBody->flattenToString();
386
387         encoder << resourceRequest.firstPartyForCookies().string();
388     }
389
390     encodePlatformData(encoder, resourceRequest);
391 }
392
393 bool ArgumentCoder<ResourceRequest>::decode(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
394 {
395     if (kShouldSerializeWebCoreData) {
396         ResourceRequest request;
397
398         String url;
399         if (!decoder.decode(url))
400             return false;
401         request.setURL(KURL(KURL(), url));
402
403         String httpMethod;
404         if (!decoder.decode(httpMethod))
405             return false;
406         request.setHTTPMethod(httpMethod);
407
408         HTTPHeaderMap headers;
409         if (!decoder.decode(headers))
410             return false;
411         request.addHTTPHeaderFields(headers);
412
413         bool hasHTTPBody;
414         if (!decoder.decode(hasHTTPBody))
415             return false;
416         if (hasHTTPBody) {
417             String httpBody;
418             if (!decoder.decode(httpBody))
419                 return false;
420             request.setHTTPBody(FormData::create(httpBody.utf8()));
421         }
422
423         String firstPartyForCookies;
424         if (!decoder.decode(firstPartyForCookies))
425             return false;
426         request.setFirstPartyForCookies(KURL(KURL(), firstPartyForCookies));
427
428         resourceRequest = request;
429     }
430
431     return decodePlatformData(decoder, resourceRequest);
432 }
433
434 void ArgumentCoder<ResourceResponse>::encode(ArgumentEncoder& encoder, const ResourceResponse& resourceResponse)
435 {
436     if (kShouldSerializeWebCoreData) {
437         bool responseIsNull = resourceResponse.isNull();
438         encoder << responseIsNull;
439         if (responseIsNull)
440             return;
441
442         encoder << resourceResponse.url().string();
443         encoder << static_cast<int32_t>(resourceResponse.httpStatusCode());
444         encoder << resourceResponse.httpHeaderFields();
445
446         encoder << resourceResponse.mimeType();
447         encoder << resourceResponse.textEncodingName();
448         encoder << static_cast<int64_t>(resourceResponse.expectedContentLength());
449         encoder << resourceResponse.httpStatusText();
450         encoder << resourceResponse.suggestedFilename();
451     }
452
453     encodePlatformData(encoder, resourceResponse);
454 }
455
456 bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder& decoder, ResourceResponse& resourceResponse)
457 {
458     if (kShouldSerializeWebCoreData) {
459         bool responseIsNull;
460         if (!decoder.decode(responseIsNull))
461             return false;
462         if (responseIsNull) {
463             resourceResponse = ResourceResponse();
464             return true;
465         }
466
467         ResourceResponse response;
468
469         String url;
470         if (!decoder.decode(url))
471             return false;
472         response.setURL(KURL(KURL(), url));
473
474         int32_t httpStatusCode;
475         if (!decoder.decode(httpStatusCode))
476             return false;
477         response.setHTTPStatusCode(httpStatusCode);
478
479         HTTPHeaderMap headers;
480         if (!decoder.decode(headers))
481             return false;
482         for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
483             response.setHTTPHeaderField(it->key, it->value);
484
485         String mimeType;
486         if (!decoder.decode(mimeType))
487             return false;
488         response.setMimeType(mimeType);
489
490         String textEncodingName;
491         if (!decoder.decode(textEncodingName))
492             return false;
493         response.setTextEncodingName(textEncodingName);
494
495         int64_t contentLength;
496         if (!decoder.decode(contentLength))
497             return false;
498         response.setExpectedContentLength(contentLength);
499
500         String httpStatusText;
501         if (!decoder.decode(httpStatusText))
502             return false;
503         response.setHTTPStatusText(httpStatusText);
504
505         String suggestedFilename;
506         if (!decoder.decode(suggestedFilename))
507             return false;
508         response.setSuggestedFilename(suggestedFilename);
509
510         resourceResponse = response;
511     }
512
513     return decodePlatformData(decoder, resourceResponse);
514 }
515
516 void ArgumentCoder<ResourceError>::encode(ArgumentEncoder& encoder, const ResourceError& resourceError)
517 {
518     if (kShouldSerializeWebCoreData) {
519         bool errorIsNull = resourceError.isNull();
520         encoder << errorIsNull;
521         if (errorIsNull)
522             return;
523
524         encoder << resourceError.domain();
525         encoder << resourceError.errorCode();
526         encoder << resourceError.failingURL();
527         encoder << resourceError.localizedDescription();
528         encoder << resourceError.isCancellation();
529         encoder << resourceError.isTimeout();
530     }
531
532     encodePlatformData(encoder, resourceError);
533 }
534
535 bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder& decoder, ResourceError& resourceError)
536 {
537     if (kShouldSerializeWebCoreData) {
538         bool errorIsNull;
539         if (!decoder.decode(errorIsNull))
540             return false;
541         if (errorIsNull) {
542             resourceError = ResourceError();
543             return true;
544         }
545
546         String domain;
547         if (!decoder.decode(domain))
548             return false;
549
550         int errorCode;
551         if (!decoder.decode(errorCode))
552             return false;
553
554         String failingURL;
555         if (!decoder.decode(failingURL))
556             return false;
557
558         String localizedDescription;
559         if (!decoder.decode(localizedDescription))
560             return false;
561
562         bool isCancellation;
563         if (!decoder.decode(isCancellation))
564             return false;
565
566         bool isTimeout;
567         if (!decoder.decode(isTimeout))
568             return false;
569
570         resourceError = ResourceError(domain, errorCode, failingURL, localizedDescription);
571         resourceError.setIsCancellation(isCancellation);
572         resourceError.setIsTimeout(isTimeout);
573     }
574
575     return decodePlatformData(decoder, resourceError);
576 }
577
578 void ArgumentCoder<WindowFeatures>::encode(ArgumentEncoder& encoder, const WindowFeatures& windowFeatures)
579 {
580     encoder << windowFeatures.x;
581     encoder << windowFeatures.y;
582     encoder << windowFeatures.width;
583     encoder << windowFeatures.height;
584     encoder << windowFeatures.xSet;
585     encoder << windowFeatures.ySet;
586     encoder << windowFeatures.widthSet;
587     encoder << windowFeatures.heightSet;
588     encoder << windowFeatures.menuBarVisible;
589     encoder << windowFeatures.statusBarVisible;
590     encoder << windowFeatures.toolBarVisible;
591     encoder << windowFeatures.locationBarVisible;
592     encoder << windowFeatures.scrollbarsVisible;
593     encoder << windowFeatures.resizable;
594     encoder << windowFeatures.fullscreen;
595     encoder << windowFeatures.dialog;
596 }
597
598 bool ArgumentCoder<WindowFeatures>::decode(ArgumentDecoder& decoder, WindowFeatures& windowFeatures)
599 {
600     if (!decoder.decode(windowFeatures.x))
601         return false;
602     if (!decoder.decode(windowFeatures.y))
603         return false;
604     if (!decoder.decode(windowFeatures.width))
605         return false;
606     if (!decoder.decode(windowFeatures.height))
607         return false;
608     if (!decoder.decode(windowFeatures.xSet))
609         return false;
610     if (!decoder.decode(windowFeatures.ySet))
611         return false;
612     if (!decoder.decode(windowFeatures.widthSet))
613         return false;
614     if (!decoder.decode(windowFeatures.heightSet))
615         return false;
616     if (!decoder.decode(windowFeatures.menuBarVisible))
617         return false;
618     if (!decoder.decode(windowFeatures.statusBarVisible))
619         return false;
620     if (!decoder.decode(windowFeatures.toolBarVisible))
621         return false;
622     if (!decoder.decode(windowFeatures.locationBarVisible))
623         return false;
624     if (!decoder.decode(windowFeatures.scrollbarsVisible))
625         return false;
626     if (!decoder.decode(windowFeatures.resizable))
627         return false;
628     if (!decoder.decode(windowFeatures.fullscreen))
629         return false;
630     if (!decoder.decode(windowFeatures.dialog))
631         return false;
632     return true;
633 }
634
635
636 void ArgumentCoder<Color>::encode(ArgumentEncoder& encoder, const Color& color)
637 {
638     if (!color.isValid()) {
639         encoder << false;
640         return;
641     }
642
643     encoder << true;
644     encoder << color.rgb();
645 }
646
647 bool ArgumentCoder<Color>::decode(ArgumentDecoder& decoder, Color& color)
648 {
649     bool isValid;
650     if (!decoder.decode(isValid))
651         return false;
652
653     if (!isValid) {
654         color = Color();
655         return true;
656     }
657
658     RGBA32 rgba;
659     if (!decoder.decode(rgba))
660         return false;
661
662     color = Color(rgba);
663     return true;
664 }
665
666
667 void ArgumentCoder<CompositionUnderline>::encode(ArgumentEncoder& encoder, const CompositionUnderline& underline)
668 {
669     encoder << underline.startOffset;
670     encoder << underline.endOffset;
671     encoder << underline.thick;
672     encoder << underline.color;
673 }
674
675 bool ArgumentCoder<CompositionUnderline>::decode(ArgumentDecoder& decoder, CompositionUnderline& underline)
676 {
677     if (!decoder.decode(underline.startOffset))
678         return false;
679     if (!decoder.decode(underline.endOffset))
680         return false;
681     if (!decoder.decode(underline.thick))
682         return false;
683     if (!decoder.decode(underline.color))
684         return false;
685
686     return true;
687 }
688
689
690 void ArgumentCoder<Cookie>::encode(ArgumentEncoder& encoder, const Cookie& cookie)
691 {
692     encoder << cookie.name;
693     encoder << cookie.value;
694     encoder << cookie.domain;
695     encoder << cookie.path;
696     encoder << cookie.expires;
697     encoder << cookie.httpOnly;
698     encoder << cookie.secure;
699     encoder << cookie.session;
700 }
701
702 bool ArgumentCoder<Cookie>::decode(ArgumentDecoder& decoder, Cookie& cookie)
703 {
704     if (!decoder.decode(cookie.name))
705         return false;
706     if (!decoder.decode(cookie.value))
707         return false;
708     if (!decoder.decode(cookie.domain))
709         return false;
710     if (!decoder.decode(cookie.path))
711         return false;
712     if (!decoder.decode(cookie.expires))
713         return false;
714     if (!decoder.decode(cookie.httpOnly))
715         return false;
716     if (!decoder.decode(cookie.secure))
717         return false;
718     if (!decoder.decode(cookie.session))
719         return false;
720
721     return true;
722 }
723
724
725 #if ENABLE(SQL_DATABASE)
726 void ArgumentCoder<DatabaseDetails>::encode(ArgumentEncoder& encoder, const DatabaseDetails& details)
727 {
728     encoder << details.name();
729     encoder << details.displayName();
730     encoder << details.expectedUsage();
731     encoder << details.currentUsage();
732 }
733     
734 bool ArgumentCoder<DatabaseDetails>::decode(ArgumentDecoder& decoder, DatabaseDetails& details)
735 {
736     String name;
737     if (!decoder.decode(name))
738         return false;
739
740     String displayName;
741     if (!decoder.decode(displayName))
742         return false;
743
744     uint64_t expectedUsage;
745     if (!decoder.decode(expectedUsage))
746         return false;
747
748     uint64_t currentUsage;
749     if (!decoder.decode(currentUsage))
750         return false;
751     
752     details = DatabaseDetails(name, displayName, expectedUsage, currentUsage);
753     return true;
754 }
755 #endif
756
757 void ArgumentCoder<DictationAlternative>::encode(ArgumentEncoder& encoder, const DictationAlternative& dictationAlternative)
758 {
759     encoder << dictationAlternative.rangeStart;
760     encoder << dictationAlternative.rangeLength;
761     encoder << dictationAlternative.dictationContext;
762 }
763
764 bool ArgumentCoder<DictationAlternative>::decode(ArgumentDecoder& decoder, DictationAlternative& dictationAlternative)
765 {
766     if (!decoder.decode(dictationAlternative.rangeStart))
767         return false;
768     if (!decoder.decode(dictationAlternative.rangeLength))
769         return false;
770     if (!decoder.decode(dictationAlternative.dictationContext))
771         return false;
772     return true;
773 }
774
775
776 void ArgumentCoder<FileChooserSettings>::encode(ArgumentEncoder& encoder, const FileChooserSettings& settings)
777 {
778     encoder << settings.allowsMultipleFiles;
779 #if ENABLE(DIRECTORY_UPLOAD)
780     encoder << settings.allowsDirectoryUpload;
781 #endif
782     encoder << settings.acceptMIMETypes;
783     encoder << settings.selectedFiles;
784 #if ENABLE(MEDIA_CAPTURE)
785     encoder << settings.capture;
786 #endif
787 }
788
789 bool ArgumentCoder<FileChooserSettings>::decode(ArgumentDecoder& decoder, FileChooserSettings& settings)
790 {
791     if (!decoder.decode(settings.allowsMultipleFiles))
792         return false;
793 #if ENABLE(DIRECTORY_UPLOAD)
794     if (!decoder.decode(settings.allowsDirectoryUpload))
795         return false;
796 #endif
797     if (!decoder.decode(settings.acceptMIMETypes))
798         return false;
799     if (!decoder.decode(settings.selectedFiles))
800         return false;
801 #if ENABLE(MEDIA_CAPTURE)
802     if (!decoder.decode(settings.capture))
803         return false;
804 #endif
805
806     return true;
807 }
808
809
810 void ArgumentCoder<GrammarDetail>::encode(ArgumentEncoder& encoder, const GrammarDetail& detail)
811 {
812     encoder << detail.location;
813     encoder << detail.length;
814     encoder << detail.guesses;
815     encoder << detail.userDescription;
816 }
817
818 bool ArgumentCoder<GrammarDetail>::decode(ArgumentDecoder& decoder, GrammarDetail& detail)
819 {
820     if (!decoder.decode(detail.location))
821         return false;
822     if (!decoder.decode(detail.length))
823         return false;
824     if (!decoder.decode(detail.guesses))
825         return false;
826     if (!decoder.decode(detail.userDescription))
827         return false;
828
829     return true;
830 }
831
832
833 void ArgumentCoder<TextCheckingResult>::encode(ArgumentEncoder& encoder, const TextCheckingResult& result)
834 {
835     encoder.encodeEnum(result.type);
836     encoder << result.location;
837     encoder << result.length;
838     encoder << result.details;
839     encoder << result.replacement;
840 }
841
842 bool ArgumentCoder<TextCheckingResult>::decode(ArgumentDecoder& decoder, TextCheckingResult& result)
843 {
844     if (!decoder.decodeEnum(result.type))
845         return false;
846     if (!decoder.decode(result.location))
847         return false;
848     if (!decoder.decode(result.length))
849         return false;
850     if (!decoder.decode(result.details))
851         return false;
852     if (!decoder.decode(result.replacement))
853         return false;
854     return true;
855 }
856
857 void ArgumentCoder<DragSession>::encode(ArgumentEncoder& encoder, const DragSession& result)
858 {
859     encoder.encodeEnum(result.operation);
860     encoder << result.mouseIsOverFileInput;
861     encoder << result.numberOfItemsToBeAccepted;
862 }
863
864 bool ArgumentCoder<DragSession>::decode(ArgumentDecoder& decoder, DragSession& result)
865 {
866     if (!decoder.decodeEnum(result.operation))
867         return false;
868     if (!decoder.decode(result.mouseIsOverFileInput))
869         return false;
870     if (!decoder.decode(result.numberOfItemsToBeAccepted))
871         return false;
872     return true;
873 }
874
875 void ArgumentCoder<KURL>::encode(ArgumentEncoder& encoder, const KURL& result)
876 {
877     encoder << result.string();
878 }
879     
880 bool ArgumentCoder<KURL>::decode(ArgumentDecoder& decoder, KURL& result)
881 {
882     String urlAsString;
883     if (!decoder.decode(urlAsString))
884         return false;
885     result = KURL(WebCore::ParsedURLString, urlAsString);
886     return true;
887 }
888
889 void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder& encoder, const WebCore::UserStyleSheet& userStyleSheet)
890 {
891     encoder << userStyleSheet.source();
892     encoder << userStyleSheet.url();
893     encoder << userStyleSheet.whitelist();
894     encoder << userStyleSheet.blacklist();
895     encoder.encodeEnum(userStyleSheet.injectedFrames());
896     encoder.encodeEnum(userStyleSheet.level());
897 }
898
899 bool ArgumentCoder<WebCore::UserStyleSheet>::decode(ArgumentDecoder& decoder, WebCore::UserStyleSheet& userStyleSheet)
900 {
901     String source;
902     if (!decoder.decode(source))
903         return false;
904
905     KURL url;
906     if (!decoder.decode(url))
907         return false;
908
909     Vector<String> whitelist;
910     if (!decoder.decode(whitelist))
911         return false;
912
913     Vector<String> blacklist;
914     if (!decoder.decode(blacklist))
915         return false;
916
917     WebCore::UserContentInjectedFrames injectedFrames;
918     if (!decoder.decodeEnum(injectedFrames))
919         return false;
920
921     WebCore::UserStyleLevel level;
922     if (!decoder.decodeEnum(level))
923         return false;
924
925     userStyleSheet = WebCore::UserStyleSheet(source, url, whitelist, blacklist, injectedFrames, level);
926     return true;
927 }
928
929 void ArgumentCoder<WebCore::UserScript>::encode(ArgumentEncoder& encoder, const WebCore::UserScript& userScript)
930 {
931     encoder << userScript.source();
932     encoder << userScript.url();
933     encoder << userScript.whitelist();
934     encoder << userScript.blacklist();
935     encoder.encodeEnum(userScript.injectionTime());
936     encoder.encodeEnum(userScript.injectedFrames());
937 }
938
939 bool ArgumentCoder<WebCore::UserScript>::decode(ArgumentDecoder& decoder, WebCore::UserScript& userScript)
940 {
941     String source;
942     if (!decoder.decode(source))
943         return false;
944
945     KURL url;
946     if (!decoder.decode(url))
947         return false;
948
949     Vector<String> whitelist;
950     if (!decoder.decode(whitelist))
951         return false;
952
953     Vector<String> blacklist;
954     if (!decoder.decode(blacklist))
955         return false;
956
957     WebCore::UserScriptInjectionTime injectionTime;
958     if (!decoder.decodeEnum(injectionTime))
959         return false;
960
961     WebCore::UserContentInjectedFrames injectedFrames;
962     if (!decoder.decodeEnum(injectedFrames))
963         return false;
964
965     userScript = WebCore::UserScript(source, url, whitelist, blacklist, injectionTime, injectedFrames);
966     return true;
967 }
968
969 } // namespace CoreIPC