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