Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

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