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