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