Source/WebKit/Shared/WebCoreArgumentCoders.cpp

   1 /*
   2  * Copyright (C) 2011-2017 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebCoreArgumentCoders.h"
  28
  29 #include "DataReference.h"
  30 #include "ShareableBitmap.h"
  31 #include <WebCore/AuthenticationChallenge.h>
  32 #include <WebCore/BlobPart.h>
  33 #include <WebCore/CacheQueryOptions.h>
  34 #include <WebCore/CertificateInfo.h>
  35 #include <WebCore/CompositionUnderline.h>
  36 #include <WebCore/Credential.h>
  37 #include <WebCore/Cursor.h>
  38 #include <WebCore/DatabaseDetails.h>
  39 #include <WebCore/DictationAlternative.h>
  40 #include <WebCore/DictionaryPopupInfo.h>
  41 #include <WebCore/DragData.h>
  42 #include <WebCore/EventTrackingRegions.h>
  43 #include <WebCore/FetchOptions.h>
  44 #include <WebCore/FileChooser.h>
  45 #include <WebCore/FilterOperation.h>
  46 #include <WebCore/FilterOperations.h>
  47 #include <WebCore/GraphicsContext.h>
  48 #include <WebCore/GraphicsLayer.h>
  49 #include <WebCore/IDBGetResult.h>
  50 #include <WebCore/Image.h>
  51 #include <WebCore/JSDOMExceptionHandling.h>
  52 #include <WebCore/Length.h>
  53 #include <WebCore/LengthBox.h>
  54 #include <WebCore/MediaSelectionOption.h>
  55 #include <WebCore/Path.h>
  56 #include <WebCore/PluginData.h>
  57 #include <WebCore/ProtectionSpace.h>
  58 #include <WebCore/Region.h>
  59 #include <WebCore/ResourceError.h>
  60 #include <WebCore/ResourceLoadStatistics.h>
  61 #include <WebCore/ResourceRequest.h>
  62 #include <WebCore/ResourceResponse.h>
  63 #include <WebCore/ScrollingConstraints.h>
  64 #include <WebCore/ScrollingCoordinator.h>
  65 #include <WebCore/SearchPopupMenu.h>
  66 #include <WebCore/TextCheckerClient.h>
  67 #include <WebCore/TextIndicator.h>
  68 #include <WebCore/TimingFunction.h>
  69 #include <WebCore/TransformationMatrix.h>
  70 #include <WebCore/URL.h>
  71 #include <WebCore/UserStyleSheet.h>
  72 #include <WebCore/ViewportArguments.h>
  73 #include <WebCore/WindowFeatures.h>
  74 #include <pal/SessionID.h>
  75 #include <wtf/MonotonicTime.h>
  76 #include <wtf/Seconds.h>
  77 #include <wtf/text/CString.h>
  78 #include <wtf/text/StringHash.h>
  79
  80 #if PLATFORM(COCOA)
  81 #include "ArgumentCodersCF.h"
  82 #include "ArgumentCodersMac.h"
  83 #endif
  84
  85 #if PLATFORM(IOS)
  86 #include <WebCore/FloatQuad.h>
  87 #include <WebCore/InspectorOverlay.h>
  88 #include <WebCore/SelectionRect.h>
  89 #include <WebCore/SharedBuffer.h>
  90 #endif // PLATFORM(IOS)
  91
  92 #if PLATFORM(IOS) || PLATFORM(WPE)
  93 #include <WebCore/Pasteboard.h>
  94 #endif
  95
  96 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
  97 #include <WebCore/MediaPlaybackTargetContext.h>
  98 #endif
  99
 100 #if ENABLE(MEDIA_SESSION)
 101 #include <WebCore/MediaSessionMetadata.h>
 102 #endif
 103
 104 #if ENABLE(MEDIA_STREAM)
 105 #include <WebCore/CaptureDevice.h>
 106 #include <WebCore/MediaConstraints.h>
 107 #endif
 108
 109 using namespace WebCore;
 110 using namespace WebKit;
 111
 112 namespace IPC {
 113
 114 static void encodeSharedBuffer(Encoder& encoder, const SharedBuffer* buffer)
 115 {
 116     SharedMemory::Handle handle;
 117     uint64_t bufferSize = buffer ? buffer->size() : 0;
 118     encoder << bufferSize;
 119     if (!bufferSize)
 120         return;
 121
 122     auto sharedMemoryBuffer = SharedMemory::allocate(buffer->size());
 123     memcpy(sharedMemoryBuffer->data(), buffer->data(), buffer->size());
 124     sharedMemoryBuffer->createHandle(handle, SharedMemory::Protection::ReadOnly);
 125     encoder << handle;
 126 }
 127
 128 static bool decodeSharedBuffer(Decoder& decoder, RefPtr<SharedBuffer>& buffer)
 129 {
 130     uint64_t bufferSize = 0;
 131     if (!decoder.decode(bufferSize))
 132         return false;
 133
 134     if (!bufferSize)
 135         return true;
 136
 137     SharedMemory::Handle handle;
 138     if (!decoder.decode(handle))
 139         return false;
 140
 141     auto sharedMemoryBuffer = SharedMemory::map(handle, SharedMemory::Protection::ReadOnly);
 142     buffer = SharedBuffer::create(static_cast<unsigned char*>(sharedMemoryBuffer->data()), bufferSize);
 143
 144     return true;
 145 }
 146
 147 void ArgumentCoder<MonotonicTime>::encode(Encoder& encoder, const MonotonicTime& time)
 148 {
 149     encoder << time.secondsSinceEpoch().value();
 150 }
 151
 152 bool ArgumentCoder<MonotonicTime>::decode(Decoder& decoder, MonotonicTime& time)
 153 {
 154     double value;
 155     if (!decoder.decode(value))
 156         return false;
 157
 158     time = MonotonicTime::fromRawSeconds(value);
 159     return true;
 160 }
 161
 162 void ArgumentCoder<Seconds>::encode(Encoder& encoder, const Seconds& seconds)
 163 {
 164     encoder << seconds.value();
 165 }
 166
 167 bool ArgumentCoder<Seconds>::decode(Decoder& decoder, Seconds& seconds)
 168 {
 169     double value;
 170     if (!decoder.decode(value))
 171         return false;
 172
 173     seconds = Seconds(value);
 174     return true;
 175 }
 176
 177 void ArgumentCoder<AffineTransform>::encode(Encoder& encoder, const AffineTransform& affineTransform)
 178 {
 179     SimpleArgumentCoder<AffineTransform>::encode(encoder, affineTransform);
 180 }
 181
 182 bool ArgumentCoder<AffineTransform>::decode(Decoder& decoder, AffineTransform& affineTransform)
 183 {
 184     return SimpleArgumentCoder<AffineTransform>::decode(decoder, affineTransform);
 185 }
 186
 187 void ArgumentCoder<CacheQueryOptions>::encode(Encoder& encoder, const CacheQueryOptions& options)
 188 {
 189     encoder << options.ignoreSearch;
 190     encoder << options.ignoreMethod;
 191     encoder << options.ignoreVary;
 192     encoder << options.cacheName;
 193 }
 194
 195 bool ArgumentCoder<CacheQueryOptions>::decode(Decoder& decoder, CacheQueryOptions& options)
 196 {
 197     bool ignoreSearch;
 198     if (!decoder.decode(ignoreSearch))
 199         return false;
 200     bool ignoreMethod;
 201     if (!decoder.decode(ignoreMethod))
 202         return false;
 203     bool ignoreVary;
 204     if (!decoder.decode(ignoreVary))
 205         return false;
 206     String cacheName;
 207     if (!decoder.decode(cacheName))
 208         return false;
 209
 210     options.ignoreSearch = ignoreSearch;
 211     options.ignoreMethod = ignoreMethod;
 212     options.ignoreVary = ignoreVary;
 213     options.cacheName = WTFMove(cacheName);
 214     return true;
 215 }
 216
 217 void ArgumentCoder<DOMCache::CacheInfo>::encode(Encoder& encoder, const DOMCache::CacheInfo& info)
 218 {
 219     encoder << info.identifier;
 220     encoder << info.name;
 221 }
 222
 223 bool ArgumentCoder<DOMCache::CacheInfo>::decode(Decoder& decoder, DOMCache::CacheInfo& record)
 224 {
 225     uint64_t identifier;
 226     if (!decoder.decode(identifier))
 227         return false;
 228
 229     String name;
 230     if (!decoder.decode(name))
 231         return false;
 232
 233     record.identifier = identifier;
 234     record.name = WTFMove(name);
 235
 236     return true;
 237 }
 238
 239 void ArgumentCoder<DOMCache::Record>::encode(Encoder& encoder, const DOMCache::Record& record)
 240 {
 241     encoder << record.identifier;
 242
 243     encoder << record.requestHeadersGuard;
 244     encoder << record.request;
 245     encoder << record.options;
 246     encoder << record.referrer;
 247
 248     encoder << record.responseHeadersGuard;
 249     encoder << record.response;
 250     encoder << record.updateResponseCounter;
 251
 252     WTF::switchOn(record.responseBody, [&](const Ref<SharedBuffer>& buffer) {
 253         encoder << true;
 254         encodeSharedBuffer(encoder, buffer.ptr());
 255     }, [&](const Ref<FormData>& formData) {
 256         encoder << false;
 257         encoder << true;
 258         formData->encode(encoder);
 259     }, [&](const std::nullptr_t&) {
 260         encoder << false;
 261         encoder << false;
 262     });
 263 }
 264
 265 bool ArgumentCoder<DOMCache::Record>::decode(Decoder& decoder, DOMCache::Record& record)
 266 {
 267     uint64_t identifier;
 268     if (!decoder.decode(identifier))
 269         return false;
 270
 271     FetchHeaders::Guard requestHeadersGuard;
 272     if (!decoder.decode(requestHeadersGuard))
 273         return false;
 274
 275     WebCore::ResourceRequest request;
 276     if (!decoder.decode(request))
 277         return false;
 278
 279     WebCore::FetchOptions options;
 280     if (!decoder.decode(options))
 281         return false;
 282
 283     String referrer;
 284     if (!decoder.decode(referrer))
 285         return false;
 286
 287     FetchHeaders::Guard responseHeadersGuard;
 288     if (!decoder.decode(responseHeadersGuard))
 289         return false;
 290
 291     WebCore::ResourceResponse response;
 292     if (!decoder.decode(response))
 293         return false;
 294
 295     uint64_t updateResponseCounter;
 296     if (!decoder.decode(updateResponseCounter))
 297         return false;
 298
 299     WebCore::DOMCache::ResponseBody responseBody;
 300     bool hasSharedBufferBody;
 301     if (!decoder.decode(hasSharedBufferBody))
 302         return false;
 303
 304     if (hasSharedBufferBody) {
 305         RefPtr<SharedBuffer> buffer;
 306         if (!decodeSharedBuffer(decoder, buffer))
 307             return false;
 308         if (buffer)
 309             responseBody = buffer.releaseNonNull();
 310     } else {
 311         bool hasFormDataBody;
 312         if (!decoder.decode(hasFormDataBody))
 313             return false;
 314         if (hasFormDataBody) {
 315             auto formData = FormData::decode(decoder);
 316             if (!formData)
 317                 return false;
 318             responseBody = formData.releaseNonNull();
 319         }
 320     }
 321
 322     record.identifier = identifier;
 323     record.requestHeadersGuard = requestHeadersGuard;
 324     record.request = WTFMove(request);
 325     record.options = WTFMove(options);
 326     record.referrer = WTFMove(referrer);
 327
 328     record.responseHeadersGuard = responseHeadersGuard;
 329     record.response = WTFMove(response);
 330     record.updateResponseCounter = updateResponseCounter;
 331     record.responseBody = WTFMove(responseBody);
 332
 333     return true;
 334 }
 335
 336 void ArgumentCoder<EventTrackingRegions>::encode(Encoder& encoder, const EventTrackingRegions& eventTrackingRegions)
 337 {
 338     encoder << eventTrackingRegions.asynchronousDispatchRegion;
 339     encoder << eventTrackingRegions.eventSpecificSynchronousDispatchRegions;
 340 }
 341
 342 bool ArgumentCoder<EventTrackingRegions>::decode(Decoder& decoder, EventTrackingRegions& eventTrackingRegions)
 343 {
 344     Region asynchronousDispatchRegion;
 345     if (!decoder.decode(asynchronousDispatchRegion))
 346         return false;
 347     HashMap<String, Region> eventSpecificSynchronousDispatchRegions;
 348     if (!decoder.decode(eventSpecificSynchronousDispatchRegions))
 349         return false;
 350     eventTrackingRegions.asynchronousDispatchRegion = WTFMove(asynchronousDispatchRegion);
 351     eventTrackingRegions.eventSpecificSynchronousDispatchRegions = WTFMove(eventSpecificSynchronousDispatchRegions);
 352     return true;
 353 }
 354
 355 void ArgumentCoder<TransformationMatrix>::encode(Encoder& encoder, const TransformationMatrix& transformationMatrix)
 356 {
 357     encoder << transformationMatrix.m11();
 358     encoder << transformationMatrix.m12();
 359     encoder << transformationMatrix.m13();
 360     encoder << transformationMatrix.m14();
 361
 362     encoder << transformationMatrix.m21();
 363     encoder << transformationMatrix.m22();
 364     encoder << transformationMatrix.m23();
 365     encoder << transformationMatrix.m24();
 366
 367     encoder << transformationMatrix.m31();
 368     encoder << transformationMatrix.m32();
 369     encoder << transformationMatrix.m33();
 370     encoder << transformationMatrix.m34();
 371
 372     encoder << transformationMatrix.m41();
 373     encoder << transformationMatrix.m42();
 374     encoder << transformationMatrix.m43();
 375     encoder << transformationMatrix.m44();
 376 }
 377
 378 bool ArgumentCoder<TransformationMatrix>::decode(Decoder& decoder, TransformationMatrix& transformationMatrix)
 379 {
 380     double m11;
 381     if (!decoder.decode(m11))
 382         return false;
 383     double m12;
 384     if (!decoder.decode(m12))
 385         return false;
 386     double m13;
 387     if (!decoder.decode(m13))
 388         return false;
 389     double m14;
 390     if (!decoder.decode(m14))
 391         return false;
 392
 393     double m21;
 394     if (!decoder.decode(m21))
 395         return false;
 396     double m22;
 397     if (!decoder.decode(m22))
 398         return false;
 399     double m23;
 400     if (!decoder.decode(m23))
 401         return false;
 402     double m24;
 403     if (!decoder.decode(m24))
 404         return false;
 405
 406     double m31;
 407     if (!decoder.decode(m31))
 408         return false;
 409     double m32;
 410     if (!decoder.decode(m32))
 411         return false;
 412     double m33;
 413     if (!decoder.decode(m33))
 414         return false;
 415     double m34;
 416     if (!decoder.decode(m34))
 417         return false;
 418
 419     double m41;
 420     if (!decoder.decode(m41))
 421         return false;
 422     double m42;
 423     if (!decoder.decode(m42))
 424         return false;
 425     double m43;
 426     if (!decoder.decode(m43))
 427         return false;
 428     double m44;
 429     if (!decoder.decode(m44))
 430         return false;
 431
 432     transformationMatrix.setMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
 433     return true;
 434 }
 435
 436 void ArgumentCoder<LinearTimingFunction>::encode(Encoder& encoder, const LinearTimingFunction& timingFunction)
 437 {
 438     encoder.encodeEnum(timingFunction.type());
 439 }
 440
 441 bool ArgumentCoder<LinearTimingFunction>::decode(Decoder&, LinearTimingFunction&)
 442 {
 443     // Type is decoded by the caller. Nothing else to decode.
 444     return true;
 445 }
 446
 447 void ArgumentCoder<CubicBezierTimingFunction>::encode(Encoder& encoder, const CubicBezierTimingFunction& timingFunction)
 448 {
 449     encoder.encodeEnum(timingFunction.type());
 450
 451     encoder << timingFunction.x1();
 452     encoder << timingFunction.y1();
 453     encoder << timingFunction.x2();
 454     encoder << timingFunction.y2();
 455
 456     encoder.encodeEnum(timingFunction.timingFunctionPreset());
 457 }
 458
 459 bool ArgumentCoder<CubicBezierTimingFunction>::decode(Decoder& decoder, CubicBezierTimingFunction& timingFunction)
 460 {
 461     // Type is decoded by the caller.
 462     double x1;
 463     if (!decoder.decode(x1))
 464         return false;
 465
 466     double y1;
 467     if (!decoder.decode(y1))
 468         return false;
 469
 470     double x2;
 471     if (!decoder.decode(x2))
 472         return false;
 473
 474     double y2;
 475     if (!decoder.decode(y2))
 476         return false;
 477
 478     CubicBezierTimingFunction::TimingFunctionPreset preset;
 479     if (!decoder.decodeEnum(preset))
 480         return false;
 481
 482     timingFunction.setValues(x1, y1, x2, y2);
 483     timingFunction.setTimingFunctionPreset(preset);
 484
 485     return true;
 486 }
 487
 488 void ArgumentCoder<StepsTimingFunction>::encode(Encoder& encoder, const StepsTimingFunction& timingFunction)
 489 {
 490     encoder.encodeEnum(timingFunction.type());
 491
 492     encoder << timingFunction.numberOfSteps();
 493     encoder << timingFunction.stepAtStart();
 494 }
 495
 496 bool ArgumentCoder<StepsTimingFunction>::decode(Decoder& decoder, StepsTimingFunction& timingFunction)
 497 {
 498     // Type is decoded by the caller.
 499     int numSteps;
 500     if (!decoder.decode(numSteps))
 501         return false;
 502
 503     bool stepAtStart;
 504     if (!decoder.decode(stepAtStart))
 505         return false;
 506
 507     timingFunction.setNumberOfSteps(numSteps);
 508     timingFunction.setStepAtStart(stepAtStart);
 509
 510     return true;
 511 }
 512
 513 void ArgumentCoder<SpringTimingFunction>::encode(Encoder& encoder, const SpringTimingFunction& timingFunction)
 514 {
 515     encoder.encodeEnum(timingFunction.type());
 516
 517     encoder << timingFunction.mass();
 518     encoder << timingFunction.stiffness();
 519     encoder << timingFunction.damping();
 520     encoder << timingFunction.initialVelocity();
 521 }
 522
 523 bool ArgumentCoder<SpringTimingFunction>::decode(Decoder& decoder, SpringTimingFunction& timingFunction)
 524 {
 525     // Type is decoded by the caller.
 526     double mass;
 527     if (!decoder.decode(mass))
 528         return false;
 529
 530     double stiffness;
 531     if (!decoder.decode(stiffness))
 532         return false;
 533
 534     double damping;
 535     if (!decoder.decode(damping))
 536         return false;
 537
 538     double initialVelocity;
 539     if (!decoder.decode(initialVelocity))
 540         return false;
 541
 542     timingFunction.setValues(mass, stiffness, damping, initialVelocity);
 543
 544     return true;
 545 }
 546
 547 void ArgumentCoder<FloatPoint>::encode(Encoder& encoder, const FloatPoint& floatPoint)
 548 {
 549     SimpleArgumentCoder<FloatPoint>::encode(encoder, floatPoint);
 550 }
 551
 552 bool ArgumentCoder<FloatPoint>::decode(Decoder& decoder, FloatPoint& floatPoint)
 553 {
 554     return SimpleArgumentCoder<FloatPoint>::decode(decoder, floatPoint);
 555 }
 556
 557
 558 void ArgumentCoder<FloatPoint3D>::encode(Encoder& encoder, const FloatPoint3D& floatPoint)
 559 {
 560     SimpleArgumentCoder<FloatPoint3D>::encode(encoder, floatPoint);
 561 }
 562
 563 bool ArgumentCoder<FloatPoint3D>::decode(Decoder& decoder, FloatPoint3D& floatPoint)
 564 {
 565     return SimpleArgumentCoder<FloatPoint3D>::decode(decoder, floatPoint);
 566 }
 567
 568
 569 void ArgumentCoder<FloatRect>::encode(Encoder& encoder, const FloatRect& floatRect)
 570 {
 571     SimpleArgumentCoder<FloatRect>::encode(encoder, floatRect);
 572 }
 573
 574 bool ArgumentCoder<FloatRect>::decode(Decoder& decoder, FloatRect& floatRect)
 575 {
 576     return SimpleArgumentCoder<FloatRect>::decode(decoder, floatRect);
 577 }
 578
 579
 580 void ArgumentCoder<FloatBoxExtent>::encode(Encoder& encoder, const FloatBoxExtent& floatBoxExtent)
 581 {
 582     SimpleArgumentCoder<FloatBoxExtent>::encode(encoder, floatBoxExtent);
 583 }
 584
 585 bool ArgumentCoder<FloatBoxExtent>::decode(Decoder& decoder, FloatBoxExtent& floatBoxExtent)
 586 {
 587     return SimpleArgumentCoder<FloatBoxExtent>::decode(decoder, floatBoxExtent);
 588 }
 589
 590
 591 void ArgumentCoder<FloatSize>::encode(Encoder& encoder, const FloatSize& floatSize)
 592 {
 593     SimpleArgumentCoder<FloatSize>::encode(encoder, floatSize);
 594 }
 595
 596 bool ArgumentCoder<FloatSize>::decode(Decoder& decoder, FloatSize& floatSize)
 597 {
 598     return SimpleArgumentCoder<FloatSize>::decode(decoder, floatSize);
 599 }
 600
 601
 602 void ArgumentCoder<FloatRoundedRect>::encode(Encoder& encoder, const FloatRoundedRect& roundedRect)
 603 {
 604     SimpleArgumentCoder<FloatRoundedRect>::encode(encoder, roundedRect);
 605 }
 606
 607 bool ArgumentCoder<FloatRoundedRect>::decode(Decoder& decoder, FloatRoundedRect& roundedRect)
 608 {
 609     return SimpleArgumentCoder<FloatRoundedRect>::decode(decoder, roundedRect);
 610 }
 611
 612 #if PLATFORM(IOS)
 613 void ArgumentCoder<FloatQuad>::encode(Encoder& encoder, const FloatQuad& floatQuad)
 614 {
 615     SimpleArgumentCoder<FloatQuad>::encode(encoder, floatQuad);
 616 }
 617
 618 bool ArgumentCoder<FloatQuad>::decode(Decoder& decoder, FloatQuad& floatQuad)
 619 {
 620     return SimpleArgumentCoder<FloatQuad>::decode(decoder, floatQuad);
 621 }
 622
 623 void ArgumentCoder<ViewportArguments>::encode(Encoder& encoder, const ViewportArguments& viewportArguments)
 624 {
 625     SimpleArgumentCoder<ViewportArguments>::encode(encoder, viewportArguments);
 626 }
 627
 628 bool ArgumentCoder<ViewportArguments>::decode(Decoder& decoder, ViewportArguments& viewportArguments)
 629 {
 630     return SimpleArgumentCoder<ViewportArguments>::decode(decoder, viewportArguments);
 631 }
 632 #endif // PLATFORM(IOS)
 633
 634
 635 void ArgumentCoder<IntPoint>::encode(Encoder& encoder, const IntPoint& intPoint)
 636 {
 637     SimpleArgumentCoder<IntPoint>::encode(encoder, intPoint);
 638 }
 639
 640 bool ArgumentCoder<IntPoint>::decode(Decoder& decoder, IntPoint& intPoint)
 641 {
 642     return SimpleArgumentCoder<IntPoint>::decode(decoder, intPoint);
 643 }
 644
 645
 646 void ArgumentCoder<IntRect>::encode(Encoder& encoder, const IntRect& intRect)
 647 {
 648     SimpleArgumentCoder<IntRect>::encode(encoder, intRect);
 649 }
 650
 651 bool ArgumentCoder<IntRect>::decode(Decoder& decoder, IntRect& intRect)
 652 {
 653     return SimpleArgumentCoder<IntRect>::decode(decoder, intRect);
 654 }
 655
 656
 657 void ArgumentCoder<IntSize>::encode(Encoder& encoder, const IntSize& intSize)
 658 {
 659     SimpleArgumentCoder<IntSize>::encode(encoder, intSize);
 660 }
 661
 662 bool ArgumentCoder<IntSize>::decode(Decoder& decoder, IntSize& intSize)
 663 {
 664     return SimpleArgumentCoder<IntSize>::decode(decoder, intSize);
 665 }
 666
 667
 668 void ArgumentCoder<LayoutSize>::encode(Encoder& encoder, const LayoutSize& layoutSize)
 669 {
 670     SimpleArgumentCoder<LayoutSize>::encode(encoder, layoutSize);
 671 }
 672
 673 bool ArgumentCoder<LayoutSize>::decode(Decoder& decoder, LayoutSize& layoutSize)
 674 {
 675     return SimpleArgumentCoder<LayoutSize>::decode(decoder, layoutSize);
 676 }
 677
 678
 679 void ArgumentCoder<LayoutPoint>::encode(Encoder& encoder, const LayoutPoint& layoutPoint)
 680 {
 681     SimpleArgumentCoder<LayoutPoint>::encode(encoder, layoutPoint);
 682 }
 683
 684 bool ArgumentCoder<LayoutPoint>::decode(Decoder& decoder, LayoutPoint& layoutPoint)
 685 {
 686     return SimpleArgumentCoder<LayoutPoint>::decode(decoder, layoutPoint);
 687 }
 688
 689
 690 static void pathEncodeApplierFunction(Encoder& encoder, const PathElement& element)
 691 {
 692     encoder.encodeEnum(element.type);
 693
 694     switch (element.type) {
 695     case PathElementMoveToPoint: // The points member will contain 1 value.
 696         encoder << element.points[0];
 697         break;
 698     case PathElementAddLineToPoint: // The points member will contain 1 value.
 699         encoder << element.points[0];
 700         break;
 701     case PathElementAddQuadCurveToPoint: // The points member will contain 2 values.
 702         encoder << element.points[0];
 703         encoder << element.points[1];
 704         break;
 705     case PathElementAddCurveToPoint: // The points member will contain 3 values.
 706         encoder << element.points[0];
 707         encoder << element.points[1];
 708         encoder << element.points[2];
 709         break;
 710     case PathElementCloseSubpath: // The points member will contain no values.
 711         break;
 712     }
 713 }
 714
 715 void ArgumentCoder<Path>::encode(Encoder& encoder, const Path& path)
 716 {
 717     uint64_t numPoints = 0;
 718     path.apply([&numPoints](const PathElement&) {
 719         ++numPoints;
 720     });
 721
 722     encoder << numPoints;
 723
 724     path.apply([&encoder](const PathElement& pathElement) {
 725         pathEncodeApplierFunction(encoder, pathElement);
 726     });
 727 }
 728
 729 bool ArgumentCoder<Path>::decode(Decoder& decoder, Path& path)
 730 {
 731     uint64_t numPoints;
 732     if (!decoder.decode(numPoints))
 733         return false;
 734
 735     path.clear();
 736
 737     for (uint64_t i = 0; i < numPoints; ++i) {
 738
 739         PathElementType elementType;
 740         if (!decoder.decodeEnum(elementType))
 741             return false;
 742
 743         switch (elementType) {
 744         case PathElementMoveToPoint: { // The points member will contain 1 value.
 745             FloatPoint point;
 746             if (!decoder.decode(point))
 747                 return false;
 748             path.moveTo(point);
 749             break;
 750         }
 751         case PathElementAddLineToPoint: { // The points member will contain 1 value.
 752             FloatPoint point;
 753             if (!decoder.decode(point))
 754                 return false;
 755             path.addLineTo(point);
 756             break;
 757         }
 758         case PathElementAddQuadCurveToPoint: { // The points member will contain 2 values.
 759             FloatPoint controlPoint;
 760             if (!decoder.decode(controlPoint))
 761                 return false;
 762
 763             FloatPoint endPoint;
 764             if (!decoder.decode(endPoint))
 765                 return false;
 766
 767             path.addQuadCurveTo(controlPoint, endPoint);
 768             break;
 769         }
 770         case PathElementAddCurveToPoint: { // The points member will contain 3 values.
 771             FloatPoint controlPoint1;
 772             if (!decoder.decode(controlPoint1))
 773                 return false;
 774
 775             FloatPoint controlPoint2;
 776             if (!decoder.decode(controlPoint2))
 777                 return false;
 778
 779             FloatPoint endPoint;
 780             if (!decoder.decode(endPoint))
 781                 return false;
 782
 783             path.addBezierCurveTo(controlPoint1, controlPoint2, endPoint);
 784             break;
 785         }
 786         case PathElementCloseSubpath: // The points member will contain no values.
 787             path.closeSubpath();
 788             break;
 789         }
 790     }
 791
 792     return true;
 793 }
 794
 795 void ArgumentCoder<RecentSearch>::encode(Encoder& encoder, const RecentSearch& recentSearch)
 796 {
 797     encoder << recentSearch.string << recentSearch.time;
 798 }
 799
 800 bool ArgumentCoder<RecentSearch>::decode(Decoder& decoder, RecentSearch& recentSearch)
 801 {
 802     if (!decoder.decode(recentSearch.string))
 803         return false;
 804
 805     if (!decoder.decode(recentSearch.time))
 806         return false;
 807
 808     return true;
 809 }
 810
 811 template<> struct ArgumentCoder<Region::Span> {
 812     static void encode(Encoder&, const Region::Span&);
 813     static bool decode(Decoder&, Region::Span&);
 814 };
 815
 816 void ArgumentCoder<Region::Span>::encode(Encoder& encoder, const Region::Span& span)
 817 {
 818     encoder << span.y;
 819     encoder << (uint64_t)span.segmentIndex;
 820 }
 821
 822 bool ArgumentCoder<Region::Span>::decode(Decoder& decoder, Region::Span& span)
 823 {
 824     if (!decoder.decode(span.y))
 825         return false;
 826
 827     uint64_t segmentIndex;
 828     if (!decoder.decode(segmentIndex))
 829         return false;
 830
 831     span.segmentIndex = segmentIndex;
 832     return true;
 833 }
 834
 835 void ArgumentCoder<Region>::encode(Encoder& encoder, const Region& region)
 836 {
 837     encoder.encode(region.shapeSegments());
 838     encoder.encode(region.shapeSpans());
 839 }
 840
 841 bool ArgumentCoder<Region>::decode(Decoder& decoder, Region& region)
 842 {
 843     Vector<int> segments;
 844     if (!decoder.decode(segments))
 845         return false;
 846
 847     Vector<Region::Span> spans;
 848     if (!decoder.decode(spans))
 849         return false;
 850
 851     region.setShapeSegments(segments);
 852     region.setShapeSpans(spans);
 853     region.updateBoundsFromShape();
 854
 855     if (!region.isValid())
 856         return false;
 857
 858     return true;
 859 }
 860
 861 void ArgumentCoder<Length>::encode(Encoder& encoder, const Length& length)
 862 {
 863     SimpleArgumentCoder<Length>::encode(encoder, length);
 864 }
 865
 866 bool ArgumentCoder<Length>::decode(Decoder& decoder, Length& length)
 867 {
 868     return SimpleArgumentCoder<Length>::decode(decoder, length);
 869 }
 870
 871
 872 void ArgumentCoder<ViewportAttributes>::encode(Encoder& encoder, const ViewportAttributes& viewportAttributes)
 873 {
 874     SimpleArgumentCoder<ViewportAttributes>::encode(encoder, viewportAttributes);
 875 }
 876
 877 bool ArgumentCoder<ViewportAttributes>::decode(Decoder& decoder, ViewportAttributes& viewportAttributes)
 878 {
 879     return SimpleArgumentCoder<ViewportAttributes>::decode(decoder, viewportAttributes);
 880 }
 881
 882
 883 void ArgumentCoder<MimeClassInfo>::encode(Encoder& encoder, const MimeClassInfo& mimeClassInfo)
 884 {
 885     encoder << mimeClassInfo.type << mimeClassInfo.desc << mimeClassInfo.extensions;
 886 }
 887
 888 bool ArgumentCoder<MimeClassInfo>::decode(Decoder& decoder, MimeClassInfo& mimeClassInfo)
 889 {
 890     if (!decoder.decode(mimeClassInfo.type))
 891         return false;
 892     if (!decoder.decode(mimeClassInfo.desc))
 893         return false;
 894     if (!decoder.decode(mimeClassInfo.extensions))
 895         return false;
 896
 897     return true;
 898 }
 899
 900
 901 void ArgumentCoder<PluginInfo>::encode(Encoder& encoder, const PluginInfo& pluginInfo)
 902 {
 903     encoder << pluginInfo.name;
 904     encoder << pluginInfo.file;
 905     encoder << pluginInfo.desc;
 906     encoder << pluginInfo.mimes;
 907     encoder << pluginInfo.isApplicationPlugin;
 908     encoder.encodeEnum(pluginInfo.clientLoadPolicy);
 909 #if PLATFORM(MAC)
 910     encoder << pluginInfo.bundleIdentifier;
 911     encoder << pluginInfo.versionString;
 912 #endif
 913 }
 914
 915 bool ArgumentCoder<PluginInfo>::decode(Decoder& decoder, PluginInfo& pluginInfo)
 916 {
 917     if (!decoder.decode(pluginInfo.name))
 918         return false;
 919     if (!decoder.decode(pluginInfo.file))
 920         return false;
 921     if (!decoder.decode(pluginInfo.desc))
 922         return false;
 923     if (!decoder.decode(pluginInfo.mimes))
 924         return false;
 925     if (!decoder.decode(pluginInfo.isApplicationPlugin))
 926         return false;
 927     if (!decoder.decodeEnum(pluginInfo.clientLoadPolicy))
 928         return false;
 929 #if PLATFORM(MAC)
 930     if (!decoder.decode(pluginInfo.bundleIdentifier))
 931         return false;
 932     if (!decoder.decode(pluginInfo.versionString))
 933         return false;
 934 #endif
 935
 936     return true;
 937 }
 938
 939 void ArgumentCoder<AuthenticationChallenge>::encode(Encoder& encoder, const AuthenticationChallenge& challenge)
 940 {
 941     encoder << challenge.protectionSpace() << challenge.proposedCredential() << challenge.previousFailureCount() << challenge.failureResponse() << challenge.error();
 942 }
 943
 944 bool ArgumentCoder<AuthenticationChallenge>::decode(Decoder& decoder, AuthenticationChallenge& challenge)
 945 {
 946     ProtectionSpace protectionSpace;
 947     if (!decoder.decode(protectionSpace))
 948         return false;
 949
 950     Credential proposedCredential;
 951     if (!decoder.decode(proposedCredential))
 952         return false;
 953
 954     unsigned previousFailureCount;
 955     if (!decoder.decode(previousFailureCount))
 956         return false;
 957
 958     ResourceResponse failureResponse;
 959     if (!decoder.decode(failureResponse))
 960         return false;
 961
 962     ResourceError error;
 963     if (!decoder.decode(error))
 964         return false;
 965
 966     challenge = AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
 967     return true;
 968 }
 969
 970
 971 void ArgumentCoder<ProtectionSpace>::encode(Encoder& encoder, const ProtectionSpace& space)
 972 {
 973     if (space.encodingRequiresPlatformData()) {
 974         encoder << true;
 975         encodePlatformData(encoder, space);
 976         return;
 977     }
 978
 979     encoder << false;
 980     encoder << space.host() << space.port() << space.realm();
 981     encoder.encodeEnum(space.authenticationScheme());
 982     encoder.encodeEnum(space.serverType());
 983 }
 984
 985 bool ArgumentCoder<ProtectionSpace>::decode(Decoder& decoder, ProtectionSpace& space)
 986 {
 987     bool hasPlatformData;
 988     if (!decoder.decode(hasPlatformData))
 989         return false;
 990
 991     if (hasPlatformData)
 992         return decodePlatformData(decoder, space);
 993
 994     String host;
 995     if (!decoder.decode(host))
 996         return false;
 997
 998     int port;
 999     if (!decoder.decode(port))
1000         return false;
1001
1002     String realm;
1003     if (!decoder.decode(realm))
1004         return false;
1005
1006     ProtectionSpaceAuthenticationScheme authenticationScheme;
1007     if (!decoder.decodeEnum(authenticationScheme))
1008         return false;
1009
1010     ProtectionSpaceServerType serverType;
1011     if (!decoder.decodeEnum(serverType))
1012         return false;
1013
1014     space = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
1015     return true;
1016 }
1017
1018 void ArgumentCoder<Credential>::encode(Encoder& encoder, const Credential& credential)
1019 {
1020     if (credential.encodingRequiresPlatformData()) {
1021         encoder << true;
1022         encodePlatformData(encoder, credential);
1023         return;
1024     }
1025
1026     encoder << false;
1027     encoder << credential.user() << credential.password();
1028     encoder.encodeEnum(credential.persistence());
1029 }
1030
1031 bool ArgumentCoder<Credential>::decode(Decoder& decoder, Credential& credential)
1032 {
1033     bool hasPlatformData;
1034     if (!decoder.decode(hasPlatformData))
1035         return false;
1036
1037     if (hasPlatformData)
1038         return decodePlatformData(decoder, credential);
1039
1040     String user;
1041     if (!decoder.decode(user))
1042         return false;
1043
1044     String password;
1045     if (!decoder.decode(password))
1046         return false;
1047
1048     CredentialPersistence persistence;
1049     if (!decoder.decodeEnum(persistence))
1050         return false;
1051
1052     credential = Credential(user, password, persistence);
1053     return true;
1054 }
1055
1056 static void encodeImage(Encoder& encoder, Image& image)
1057 {
1058     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(IntSize(image.size()), { });
1059     bitmap->createGraphicsContext()->drawImage(image, IntPoint());
1060
1061     ShareableBitmap::Handle handle;
1062     bitmap->createHandle(handle);
1063
1064     encoder << handle;
1065 }
1066
1067 static bool decodeImage(Decoder& decoder, RefPtr<Image>& image)
1068 {
1069     ShareableBitmap::Handle handle;
1070     if (!decoder.decode(handle))
1071         return false;
1072
1073     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
1074     if (!bitmap)
1075         return false;
1076     image = bitmap->createImage();
1077     if (!image)
1078         return false;
1079     return true;
1080 }
1081
1082 static void encodeOptionalImage(Encoder& encoder, Image* image)
1083 {
1084     bool hasImage = !!image;
1085     encoder << hasImage;
1086
1087     if (hasImage)
1088         encodeImage(encoder, *image);
1089 }
1090
1091 static bool decodeOptionalImage(Decoder& decoder, RefPtr<Image>& image)
1092 {
1093     image = nullptr;
1094
1095     bool hasImage;
1096     if (!decoder.decode(hasImage))
1097         return false;
1098
1099     if (!hasImage)
1100         return true;
1101
1102     return decodeImage(decoder, image);
1103 }
1104
1105 #if !PLATFORM(IOS)
1106 void ArgumentCoder<Cursor>::encode(Encoder& encoder, const Cursor& cursor)
1107 {
1108     encoder.encodeEnum(cursor.type());
1109
1110     if (cursor.type() != Cursor::Custom)
1111         return;
1112
1113     if (cursor.image()->isNull()) {
1114         encoder << false; // There is no valid image being encoded.
1115         return;
1116     }
1117
1118     encoder << true;
1119     encodeImage(encoder, *cursor.image());
1120     encoder << cursor.hotSpot();
1121 #if ENABLE(MOUSE_CURSOR_SCALE)
1122     encoder << cursor.imageScaleFactor();
1123 #endif
1124 }
1125
1126 bool ArgumentCoder<Cursor>::decode(Decoder& decoder, Cursor& cursor)
1127 {
1128     Cursor::Type type;
1129     if (!decoder.decodeEnum(type))
1130         return false;
1131
1132     if (type > Cursor::Custom)
1133         return false;
1134
1135     if (type != Cursor::Custom) {
1136         const Cursor& cursorReference = Cursor::fromType(type);
1137         // Calling platformCursor here will eagerly create the platform cursor for the cursor singletons inside WebCore.
1138         // This will avoid having to re-create the platform cursors over and over.
1139         (void)cursorReference.platformCursor();
1140
1141         cursor = cursorReference;
1142         return true;
1143     }
1144
1145     bool isValidImagePresent;
1146     if (!decoder.decode(isValidImagePresent))
1147         return false;
1148
1149     if (!isValidImagePresent) {
1150         cursor = Cursor(&Image::nullImage(), IntPoint());
1151         return true;
1152     }
1153
1154     RefPtr<Image> image;
1155     if (!decodeImage(decoder, image))
1156         return false;
1157
1158     IntPoint hotSpot;
1159     if (!decoder.decode(hotSpot))
1160         return false;
1161
1162     if (!image->rect().contains(hotSpot))
1163         return false;
1164
1165 #if ENABLE(MOUSE_CURSOR_SCALE)
1166     float scale;
1167     if (!decoder.decode(scale))
1168         return false;
1169
1170     cursor = Cursor(image.get(), hotSpot, scale);
1171 #else
1172     cursor = Cursor(image.get(), hotSpot);
1173 #endif
1174     return true;
1175 }
1176 #endif
1177
1178 void ArgumentCoder<ResourceRequest>::encode(Encoder& encoder, const ResourceRequest& resourceRequest)
1179 {
1180     encoder << resourceRequest.cachePartition();
1181     encoder << resourceRequest.hiddenFromInspector();
1182
1183     if (resourceRequest.encodingRequiresPlatformData()) {
1184         encoder << true;
1185         encodePlatformData(encoder, resourceRequest);
1186         return;
1187     }
1188     encoder << false;
1189     resourceRequest.encodeWithoutPlatformData(encoder);
1190 }
1191
1192 bool ArgumentCoder<ResourceRequest>::decode(Decoder& decoder, ResourceRequest& resourceRequest)
1193 {
1194     String cachePartition;
1195     if (!decoder.decode(cachePartition))
1196         return false;
1197     resourceRequest.setCachePartition(cachePartition);
1198
1199     bool isHiddenFromInspector;
1200     if (!decoder.decode(isHiddenFromInspector))
1201         return false;
1202     resourceRequest.setHiddenFromInspector(isHiddenFromInspector);
1203
1204     bool hasPlatformData;
1205     if (!decoder.decode(hasPlatformData))
1206         return false;
1207     if (hasPlatformData)
1208         return decodePlatformData(decoder, resourceRequest);
1209
1210     return resourceRequest.decodeWithoutPlatformData(decoder);
1211 }
1212
1213 void ArgumentCoder<ResourceError>::encode(Encoder& encoder, const ResourceError& resourceError)
1214 {
1215     encodePlatformData(encoder, resourceError);
1216 }
1217
1218 bool ArgumentCoder<ResourceError>::decode(Decoder& decoder, ResourceError& resourceError)
1219 {
1220     return decodePlatformData(decoder, resourceError);
1221 }
1222
1223 #if PLATFORM(IOS)
1224
1225 void ArgumentCoder<SelectionRect>::encode(Encoder& encoder, const SelectionRect& selectionRect)
1226 {
1227     encoder << selectionRect.rect();
1228     encoder << static_cast<uint32_t>(selectionRect.direction());
1229     encoder << selectionRect.minX();
1230     encoder << selectionRect.maxX();
1231     encoder << selectionRect.maxY();
1232     encoder << selectionRect.lineNumber();
1233     encoder << selectionRect.isLineBreak();
1234     encoder << selectionRect.isFirstOnLine();
1235     encoder << selectionRect.isLastOnLine();
1236     encoder << selectionRect.containsStart();
1237     encoder << selectionRect.containsEnd();
1238     encoder << selectionRect.isHorizontal();
1239 }
1240
1241 bool ArgumentCoder<SelectionRect>::decode(Decoder& decoder, SelectionRect& selectionRect)
1242 {
1243     IntRect rect;
1244     if (!decoder.decode(rect))
1245         return false;
1246     selectionRect.setRect(rect);
1247
1248     uint32_t direction;
1249     if (!decoder.decode(direction))
1250         return false;
1251     selectionRect.setDirection((TextDirection)direction);
1252
1253     int intValue;
1254     if (!decoder.decode(intValue))
1255         return false;
1256     selectionRect.setMinX(intValue);
1257
1258     if (!decoder.decode(intValue))
1259         return false;
1260     selectionRect.setMaxX(intValue);
1261
1262     if (!decoder.decode(intValue))
1263         return false;
1264     selectionRect.setMaxY(intValue);
1265
1266     if (!decoder.decode(intValue))
1267         return false;
1268     selectionRect.setLineNumber(intValue);
1269
1270     bool boolValue;
1271     if (!decoder.decode(boolValue))
1272         return false;
1273     selectionRect.setIsLineBreak(boolValue);
1274
1275     if (!decoder.decode(boolValue))
1276         return false;
1277     selectionRect.setIsFirstOnLine(boolValue);
1278
1279     if (!decoder.decode(boolValue))
1280         return false;
1281     selectionRect.setIsLastOnLine(boolValue);
1282
1283     if (!decoder.decode(boolValue))
1284         return false;
1285     selectionRect.setContainsStart(boolValue);
1286
1287     if (!decoder.decode(boolValue))
1288         return false;
1289     selectionRect.setContainsEnd(boolValue);
1290
1291     if (!decoder.decode(boolValue))
1292         return false;
1293     selectionRect.setIsHorizontal(boolValue);
1294
1295     return true;
1296 }
1297
1298 #endif
1299
1300 void ArgumentCoder<WindowFeatures>::encode(Encoder& encoder, const WindowFeatures& windowFeatures)
1301 {
1302     encoder << windowFeatures.x;
1303     encoder << windowFeatures.y;
1304     encoder << windowFeatures.width;
1305     encoder << windowFeatures.height;
1306     encoder << windowFeatures.menuBarVisible;
1307     encoder << windowFeatures.statusBarVisible;
1308     encoder << windowFeatures.toolBarVisible;
1309     encoder << windowFeatures.locationBarVisible;
1310     encoder << windowFeatures.scrollbarsVisible;
1311     encoder << windowFeatures.resizable;
1312     encoder << windowFeatures.fullscreen;
1313     encoder << windowFeatures.dialog;
1314 }
1315
1316 bool ArgumentCoder<WindowFeatures>::decode(Decoder& decoder, WindowFeatures& windowFeatures)
1317 {
1318     if (!decoder.decode(windowFeatures.x))
1319         return false;
1320     if (!decoder.decode(windowFeatures.y))
1321         return false;
1322     if (!decoder.decode(windowFeatures.width))
1323         return false;
1324     if (!decoder.decode(windowFeatures.height))
1325         return false;
1326     if (!decoder.decode(windowFeatures.menuBarVisible))
1327         return false;
1328     if (!decoder.decode(windowFeatures.statusBarVisible))
1329         return false;
1330     if (!decoder.decode(windowFeatures.toolBarVisible))
1331         return false;
1332     if (!decoder.decode(windowFeatures.locationBarVisible))
1333         return false;
1334     if (!decoder.decode(windowFeatures.scrollbarsVisible))
1335         return false;
1336     if (!decoder.decode(windowFeatures.resizable))
1337         return false;
1338     if (!decoder.decode(windowFeatures.fullscreen))
1339         return false;
1340     if (!decoder.decode(windowFeatures.dialog))
1341         return false;
1342     return true;
1343 }
1344
1345
1346 void ArgumentCoder<Color>::encode(Encoder& encoder, const Color& color)
1347 {
1348     if (color.isExtended()) {
1349         encoder << true;
1350         encoder << color.asExtended().red();
1351         encoder << color.asExtended().green();
1352         encoder << color.asExtended().blue();
1353         encoder << color.asExtended().alpha();
1354         encoder << color.asExtended().colorSpace();
1355         return;
1356     }
1357
1358     encoder << false;
1359
1360     if (!color.isValid()) {
1361         encoder << false;
1362         return;
1363     }
1364
1365     encoder << true;
1366     encoder << color.rgb();
1367 }
1368
1369 bool ArgumentCoder<Color>::decode(Decoder& decoder, Color& color)
1370 {
1371     bool isExtended;
1372     if (!decoder.decode(isExtended))
1373         return false;
1374
1375     if (isExtended) {
1376         float red;
1377         float green;
1378         float blue;
1379         float alpha;
1380         ColorSpace colorSpace;
1381         if (!decoder.decode(red))
1382             return false;
1383         if (!decoder.decode(green))
1384             return false;
1385         if (!decoder.decode(blue))
1386             return false;
1387         if (!decoder.decode(alpha))
1388             return false;
1389         if (!decoder.decode(colorSpace))
1390             return false;
1391         color = Color(red, green, blue, alpha, colorSpace);
1392         return true;
1393     }
1394
1395     bool isValid;
1396     if (!decoder.decode(isValid))
1397         return false;
1398
1399     if (!isValid) {
1400         color = Color();
1401         return true;
1402     }
1403
1404     RGBA32 rgba;
1405     if (!decoder.decode(rgba))
1406         return false;
1407
1408     color = Color(rgba);
1409     return true;
1410 }
1411
1412 #if ENABLE(DRAG_SUPPORT)
1413 void ArgumentCoder<DragData>::encode(Encoder& encoder, const DragData& dragData)
1414 {
1415     encoder << dragData.clientPosition();
1416     encoder << dragData.globalPosition();
1417     encoder.encodeEnum(dragData.draggingSourceOperationMask());
1418     encoder.encodeEnum(dragData.flags());
1419 #if PLATFORM(COCOA)
1420     encoder << dragData.pasteboardName();
1421     encoder << dragData.fileNames();
1422 #endif
1423     encoder.encodeEnum(dragData.dragDestinationAction());
1424 }
1425
1426 bool ArgumentCoder<DragData>::decode(Decoder& decoder, DragData& dragData)
1427 {
1428     IntPoint clientPosition;
1429     if (!decoder.decode(clientPosition))
1430         return false;
1431
1432     IntPoint globalPosition;
1433     if (!decoder.decode(globalPosition))
1434         return false;
1435
1436     DragOperation draggingSourceOperationMask;
1437     if (!decoder.decodeEnum(draggingSourceOperationMask))
1438         return false;
1439
1440     DragApplicationFlags applicationFlags;
1441     if (!decoder.decodeEnum(applicationFlags))
1442         return false;
1443
1444     String pasteboardName;
1445     Vector<String> fileNames;
1446 #if PLATFORM(COCOA)
1447     if (!decoder.decode(pasteboardName))
1448         return false;
1449
1450     if (!decoder.decode(fileNames))
1451         return false;
1452 #endif
1453
1454     DragDestinationAction destinationAction;
1455     if (!decoder.decodeEnum(destinationAction))
1456         return false;
1457
1458     dragData = DragData(pasteboardName, clientPosition, globalPosition, draggingSourceOperationMask, applicationFlags, destinationAction);
1459     dragData.setFileNames(fileNames);
1460
1461     return true;
1462 }
1463 #endif
1464
1465 void ArgumentCoder<CompositionUnderline>::encode(Encoder& encoder, const CompositionUnderline& underline)
1466 {
1467     encoder << underline.startOffset;
1468     encoder << underline.endOffset;
1469     encoder << underline.thick;
1470     encoder << underline.color;
1471 }
1472
1473 bool ArgumentCoder<CompositionUnderline>::decode(Decoder& decoder, CompositionUnderline& underline)
1474 {
1475     if (!decoder.decode(underline.startOffset))
1476         return false;
1477     if (!decoder.decode(underline.endOffset))
1478         return false;
1479     if (!decoder.decode(underline.thick))
1480         return false;
1481     if (!decoder.decode(underline.color))
1482         return false;
1483
1484     return true;
1485 }
1486
1487 void ArgumentCoder<DatabaseDetails>::encode(Encoder& encoder, const DatabaseDetails& details)
1488 {
1489     encoder << details.name();
1490     encoder << details.displayName();
1491     encoder << details.expectedUsage();
1492     encoder << details.currentUsage();
1493     encoder << details.creationTime();
1494     encoder << details.modificationTime();
1495 }
1496
1497 bool ArgumentCoder<DatabaseDetails>::decode(Decoder& decoder, DatabaseDetails& details)
1498 {
1499     String name;
1500     if (!decoder.decode(name))
1501         return false;
1502
1503     String displayName;
1504     if (!decoder.decode(displayName))
1505         return false;
1506
1507     uint64_t expectedUsage;
1508     if (!decoder.decode(expectedUsage))
1509         return false;
1510
1511     uint64_t currentUsage;
1512     if (!decoder.decode(currentUsage))
1513         return false;
1514
1515     double creationTime;
1516     if (!decoder.decode(creationTime))
1517         return false;
1518
1519     double modificationTime;
1520     if (!decoder.decode(modificationTime))
1521         return false;
1522
1523     details = DatabaseDetails(name, displayName, expectedUsage, currentUsage, creationTime, modificationTime);
1524     return true;
1525 }
1526
1527 #if PLATFORM(IOS)
1528
1529 void ArgumentCoder<Highlight>::encode(Encoder& encoder, const Highlight& highlight)
1530 {
1531     encoder << static_cast<uint32_t>(highlight.type);
1532     encoder << highlight.usePageCoordinates;
1533     encoder << highlight.contentColor;
1534     encoder << highlight.contentOutlineColor;
1535     encoder << highlight.paddingColor;
1536     encoder << highlight.borderColor;
1537     encoder << highlight.marginColor;
1538     encoder << highlight.quads;
1539 }
1540
1541 bool ArgumentCoder<Highlight>::decode(Decoder& decoder, Highlight& highlight)
1542 {
1543     uint32_t type;
1544     if (!decoder.decode(type))
1545         return false;
1546     highlight.type = (HighlightType)type;
1547
1548     if (!decoder.decode(highlight.usePageCoordinates))
1549         return false;
1550     if (!decoder.decode(highlight.contentColor))
1551         return false;
1552     if (!decoder.decode(highlight.contentOutlineColor))
1553         return false;
1554     if (!decoder.decode(highlight.paddingColor))
1555         return false;
1556     if (!decoder.decode(highlight.borderColor))
1557         return false;
1558     if (!decoder.decode(highlight.marginColor))
1559         return false;
1560     if (!decoder.decode(highlight.quads))
1561         return false;
1562     return true;
1563 }
1564
1565 void ArgumentCoder<PasteboardURL>::encode(Encoder& encoder, const PasteboardURL& content)
1566 {
1567     encoder << content.url;
1568     encoder << content.title;
1569 }
1570
1571 bool ArgumentCoder<PasteboardURL>::decode(Decoder& decoder, PasteboardURL& content)
1572 {
1573     if (!decoder.decode(content.url))
1574         return false;
1575
1576     if (!decoder.decode(content.title))
1577         return false;
1578
1579     return true;
1580 }
1581
1582 static void encodeClientTypesAndData(Encoder& encoder, const Vector<String>& types, const Vector<RefPtr<SharedBuffer>>& data)
1583 {
1584     ASSERT(types.size() == data.size());
1585     encoder << types;
1586     encoder << static_cast<uint64_t>(data.size());
1587     for (auto& buffer : data)
1588         encodeSharedBuffer(encoder, buffer.get());
1589 }
1590
1591 static bool decodeClientTypesAndData(Decoder& decoder, Vector<String>& types, Vector<RefPtr<SharedBuffer>>& data)
1592 {
1593     if (!decoder.decode(types))
1594         return false;
1595
1596     uint64_t dataSize;
1597     if (!decoder.decode(dataSize))
1598         return false;
1599
1600     ASSERT(dataSize == types.size());
1601
1602     data.resize(dataSize);
1603     for (auto& buffer : data)
1604         decodeSharedBuffer(decoder, buffer);
1605
1606     return true;
1607 }
1608
1609 void ArgumentCoder<PasteboardWebContent>::encode(Encoder& encoder, const PasteboardWebContent& content)
1610 {
1611     encoder << content.canSmartCopyOrDelete;
1612     encoder << content.dataInStringFormat;
1613
1614     encodeSharedBuffer(encoder, content.dataInWebArchiveFormat.get());
1615     encodeSharedBuffer(encoder, content.dataInRTFDFormat.get());
1616     encodeSharedBuffer(encoder, content.dataInRTFFormat.get());
1617     encodeSharedBuffer(encoder, content.dataInAttributedStringFormat.get());
1618
1619     encodeClientTypesAndData(encoder, content.clientTypes, content.clientData);
1620 }
1621
1622 bool ArgumentCoder<PasteboardWebContent>::decode(Decoder& decoder, PasteboardWebContent& content)
1623 {
1624     if (!decoder.decode(content.canSmartCopyOrDelete))
1625         return false;
1626     if (!decoder.decode(content.dataInStringFormat))
1627         return false;
1628     if (!decodeSharedBuffer(decoder, content.dataInWebArchiveFormat))
1629         return false;
1630     if (!decodeSharedBuffer(decoder, content.dataInRTFDFormat))
1631         return false;
1632     if (!decodeSharedBuffer(decoder, content.dataInRTFFormat))
1633         return false;
1634     if (!decodeSharedBuffer(decoder, content.dataInAttributedStringFormat))
1635         return false;
1636     if (!decodeClientTypesAndData(decoder, content.clientTypes, content.clientData))
1637         return false;
1638     return true;
1639 }
1640
1641 void ArgumentCoder<PasteboardImage>::encode(Encoder& encoder, const PasteboardImage& pasteboardImage)
1642 {
1643     encodeOptionalImage(encoder, pasteboardImage.image.get());
1644     encoder << pasteboardImage.url.url;
1645     encoder << pasteboardImage.url.title;
1646     encoder << pasteboardImage.resourceMIMEType;
1647     encoder << pasteboardImage.suggestedName;
1648     encoder << pasteboardImage.imageSize;
1649     if (pasteboardImage.resourceData)
1650         encodeSharedBuffer(encoder, pasteboardImage.resourceData.get());
1651     encodeClientTypesAndData(encoder, pasteboardImage.clientTypes, pasteboardImage.clientData);
1652 }
1653
1654 bool ArgumentCoder<PasteboardImage>::decode(Decoder& decoder, PasteboardImage& pasteboardImage)
1655 {
1656     if (!decodeOptionalImage(decoder, pasteboardImage.image))
1657         return false;
1658     if (!decoder.decode(pasteboardImage.url.url))
1659         return false;
1660     if (!decoder.decode(pasteboardImage.url.title))
1661         return false;
1662     if (!decoder.decode(pasteboardImage.resourceMIMEType))
1663         return false;
1664     if (!decoder.decode(pasteboardImage.suggestedName))
1665         return false;
1666     if (!decoder.decode(pasteboardImage.imageSize))
1667         return false;
1668     if (!decodeSharedBuffer(decoder, pasteboardImage.resourceData))
1669         return false;
1670     if (!decodeClientTypesAndData(decoder, pasteboardImage.clientTypes, pasteboardImage.clientData))
1671         return false;
1672     return true;
1673 }
1674
1675 #endif
1676
1677 #if PLATFORM(WPE)
1678 void ArgumentCoder<PasteboardWebContent>::encode(Encoder& encoder, const PasteboardWebContent& content)
1679 {
1680     encoder << content.text;
1681     encoder << content.markup;
1682 }
1683
1684 bool ArgumentCoder<PasteboardWebContent>::decode(Decoder& decoder, PasteboardWebContent& content)
1685 {
1686     if (!decoder.decode(content.text))
1687         return false;
1688     if (!decoder.decode(content.markup))
1689         return false;
1690     return true;
1691 }
1692 #endif // PLATFORM(WPE)
1693
1694 void ArgumentCoder<DictationAlternative>::encode(Encoder& encoder, const DictationAlternative& dictationAlternative)
1695 {
1696     encoder << dictationAlternative.rangeStart;
1697     encoder << dictationAlternative.rangeLength;
1698     encoder << dictationAlternative.dictationContext;
1699 }
1700
1701 bool ArgumentCoder<DictationAlternative>::decode(Decoder& decoder, DictationAlternative& dictationAlternative)
1702 {
1703     if (!decoder.decode(dictationAlternative.rangeStart))
1704         return false;
1705     if (!decoder.decode(dictationAlternative.rangeLength))
1706         return false;
1707     if (!decoder.decode(dictationAlternative.dictationContext))
1708         return false;
1709     return true;
1710 }
1711
1712
1713 void ArgumentCoder<FileChooserSettings>::encode(Encoder& encoder, const FileChooserSettings& settings)
1714 {
1715     encoder << settings.allowsMultipleFiles;
1716     encoder << settings.acceptMIMETypes;
1717     encoder << settings.acceptFileExtensions;
1718     encoder << settings.selectedFiles;
1719 #if ENABLE(MEDIA_CAPTURE)
1720     encoder.encodeEnum(settings.mediaCaptureType);
1721 #endif
1722 }
1723
1724 bool ArgumentCoder<FileChooserSettings>::decode(Decoder& decoder, FileChooserSettings& settings)
1725 {
1726     if (!decoder.decode(settings.allowsMultipleFiles))
1727         return false;
1728     if (!decoder.decode(settings.acceptMIMETypes))
1729         return false;
1730     if (!decoder.decode(settings.acceptFileExtensions))
1731         return false;
1732     if (!decoder.decode(settings.selectedFiles))
1733         return false;
1734 #if ENABLE(MEDIA_CAPTURE)
1735     if (!decoder.decodeEnum(settings.mediaCaptureType))
1736         return false;
1737 #endif
1738
1739     return true;
1740 }
1741
1742
1743 void ArgumentCoder<GrammarDetail>::encode(Encoder& encoder, const GrammarDetail& detail)
1744 {
1745     encoder << detail.location;
1746     encoder << detail.length;
1747     encoder << detail.guesses;
1748     encoder << detail.userDescription;
1749 }
1750
1751 bool ArgumentCoder<GrammarDetail>::decode(Decoder& decoder, GrammarDetail& detail)
1752 {
1753     if (!decoder.decode(detail.location))
1754         return false;
1755     if (!decoder.decode(detail.length))
1756         return false;
1757     if (!decoder.decode(detail.guesses))
1758         return false;
1759     if (!decoder.decode(detail.userDescription))
1760         return false;
1761
1762     return true;
1763 }
1764
1765 void ArgumentCoder<TextCheckingRequestData>::encode(Encoder& encoder, const TextCheckingRequestData& request)
1766 {
1767     encoder << request.sequence();
1768     encoder << request.text();
1769     encoder << request.mask();
1770     encoder.encodeEnum(request.processType());
1771 }
1772
1773 bool ArgumentCoder<TextCheckingRequestData>::decode(Decoder& decoder, TextCheckingRequestData& request)
1774 {
1775     int sequence;
1776     if (!decoder.decode(sequence))
1777         return false;
1778
1779     String text;
1780     if (!decoder.decode(text))
1781         return false;
1782
1783     TextCheckingTypeMask mask;
1784     if (!decoder.decode(mask))
1785         return false;
1786
1787     TextCheckingProcessType processType;
1788     if (!decoder.decodeEnum(processType))
1789         return false;
1790
1791     request = TextCheckingRequestData(sequence, text, mask, processType);
1792     return true;
1793 }
1794
1795 void ArgumentCoder<TextCheckingResult>::encode(Encoder& encoder, const TextCheckingResult& result)
1796 {
1797     encoder.encodeEnum(result.type);
1798     encoder << result.location;
1799     encoder << result.length;
1800     encoder << result.details;
1801     encoder << result.replacement;
1802 }
1803
1804 bool ArgumentCoder<TextCheckingResult>::decode(Decoder& decoder, TextCheckingResult& result)
1805 {
1806     if (!decoder.decodeEnum(result.type))
1807         return false;
1808     if (!decoder.decode(result.location))
1809         return false;
1810     if (!decoder.decode(result.length))
1811         return false;
1812     if (!decoder.decode(result.details))
1813         return false;
1814     if (!decoder.decode(result.replacement))
1815         return false;
1816     return true;
1817 }
1818
1819 void ArgumentCoder<URL>::encode(Encoder& encoder, const URL& result)
1820 {
1821     encoder << result.string();
1822 }
1823
1824 bool ArgumentCoder<URL>::decode(Decoder& decoder, URL& result)
1825 {
1826     String urlAsString;
1827     if (!decoder.decode(urlAsString))
1828         return false;
1829     result = URL(ParsedURLString, urlAsString);
1830     return true;
1831 }
1832
1833 void ArgumentCoder<UserStyleSheet>::encode(Encoder& encoder, const UserStyleSheet& userStyleSheet)
1834 {
1835     encoder << userStyleSheet.source();
1836     encoder << userStyleSheet.url();
1837     encoder << userStyleSheet.whitelist();
1838     encoder << userStyleSheet.blacklist();
1839     encoder.encodeEnum(userStyleSheet.injectedFrames());
1840     encoder.encodeEnum(userStyleSheet.level());
1841 }
1842
1843 bool ArgumentCoder<UserStyleSheet>::decode(Decoder& decoder, UserStyleSheet& userStyleSheet)
1844 {
1845     String source;
1846     if (!decoder.decode(source))
1847         return false;
1848
1849     URL url;
1850     if (!decoder.decode(url))
1851         return false;
1852
1853     Vector<String> whitelist;
1854     if (!decoder.decode(whitelist))
1855         return false;
1856
1857     Vector<String> blacklist;
1858     if (!decoder.decode(blacklist))
1859         return false;
1860
1861     UserContentInjectedFrames injectedFrames;
1862     if (!decoder.decodeEnum(injectedFrames))
1863         return false;
1864
1865     UserStyleLevel level;
1866     if (!decoder.decodeEnum(level))
1867         return false;
1868
1869     userStyleSheet = UserStyleSheet(source, url, WTFMove(whitelist), WTFMove(blacklist), injectedFrames, level);
1870     return true;
1871 }
1872
1873 #if ENABLE(MEDIA_SESSION)
1874 void ArgumentCoder<MediaSessionMetadata>::encode(Encoder& encoder, const MediaSessionMetadata& result)
1875 {
1876     encoder << result.artist();
1877     encoder << result.album();
1878     encoder << result.title();
1879     encoder << result.artworkURL();
1880 }
1881
1882 bool ArgumentCoder<MediaSessionMetadata>::decode(Decoder& decoder, MediaSessionMetadata& result)
1883 {
1884     String artist, album, title;
1885     URL artworkURL;
1886     if (!decoder.decode(artist))
1887         return false;
1888     if (!decoder.decode(album))
1889         return false;
1890     if (!decoder.decode(title))
1891         return false;
1892     if (!decoder.decode(artworkURL))
1893         return false;
1894     result = MediaSessionMetadata(title, artist, album, artworkURL);
1895     return true;
1896 }
1897 #endif
1898
1899 void ArgumentCoder<ScrollableAreaParameters>::encode(Encoder& encoder, const ScrollableAreaParameters& parameters)
1900 {
1901     encoder.encodeEnum(parameters.horizontalScrollElasticity);
1902     encoder.encodeEnum(parameters.verticalScrollElasticity);
1903
1904     encoder.encodeEnum(parameters.horizontalScrollbarMode);
1905     encoder.encodeEnum(parameters.verticalScrollbarMode);
1906
1907     encoder << parameters.hasEnabledHorizontalScrollbar;
1908     encoder << parameters.hasEnabledVerticalScrollbar;
1909 }
1910
1911 bool ArgumentCoder<ScrollableAreaParameters>::decode(Decoder& decoder, ScrollableAreaParameters& params)
1912 {
1913     if (!decoder.decodeEnum(params.horizontalScrollElasticity))
1914         return false;
1915     if (!decoder.decodeEnum(params.verticalScrollElasticity))
1916         return false;
1917
1918     if (!decoder.decodeEnum(params.horizontalScrollbarMode))
1919         return false;
1920     if (!decoder.decodeEnum(params.verticalScrollbarMode))
1921         return false;
1922
1923     if (!decoder.decode(params.hasEnabledHorizontalScrollbar))
1924         return false;
1925     if (!decoder.decode(params.hasEnabledVerticalScrollbar))
1926         return false;
1927
1928     return true;
1929 }
1930
1931 void ArgumentCoder<FixedPositionViewportConstraints>::encode(Encoder& encoder, const FixedPositionViewportConstraints& viewportConstraints)
1932 {
1933     encoder << viewportConstraints.alignmentOffset();
1934     encoder << viewportConstraints.anchorEdges();
1935
1936     encoder << viewportConstraints.viewportRectAtLastLayout();
1937     encoder << viewportConstraints.layerPositionAtLastLayout();
1938 }
1939
1940 bool ArgumentCoder<FixedPositionViewportConstraints>::decode(Decoder& decoder, FixedPositionViewportConstraints& viewportConstraints)
1941 {
1942     FloatSize alignmentOffset;
1943     if (!decoder.decode(alignmentOffset))
1944         return false;
1945
1946     ViewportConstraints::AnchorEdges anchorEdges;
1947     if (!decoder.decode(anchorEdges))
1948         return false;
1949
1950     FloatRect viewportRectAtLastLayout;
1951     if (!decoder.decode(viewportRectAtLastLayout))
1952         return false;
1953
1954     FloatPoint layerPositionAtLastLayout;
1955     if (!decoder.decode(layerPositionAtLastLayout))
1956         return false;
1957
1958     viewportConstraints = FixedPositionViewportConstraints();
1959     viewportConstraints.setAlignmentOffset(alignmentOffset);
1960     viewportConstraints.setAnchorEdges(anchorEdges);
1961
1962     viewportConstraints.setViewportRectAtLastLayout(viewportRectAtLastLayout);
1963     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
1964
1965     return true;
1966 }
1967
1968 void ArgumentCoder<StickyPositionViewportConstraints>::encode(Encoder& encoder, const StickyPositionViewportConstraints& viewportConstraints)
1969 {
1970     encoder << viewportConstraints.alignmentOffset();
1971     encoder << viewportConstraints.anchorEdges();
1972
1973     encoder << viewportConstraints.leftOffset();
1974     encoder << viewportConstraints.rightOffset();
1975     encoder << viewportConstraints.topOffset();
1976     encoder << viewportConstraints.bottomOffset();
1977
1978     encoder << viewportConstraints.constrainingRectAtLastLayout();
1979     encoder << viewportConstraints.containingBlockRect();
1980     encoder << viewportConstraints.stickyBoxRect();
1981
1982     encoder << viewportConstraints.stickyOffsetAtLastLayout();
1983     encoder << viewportConstraints.layerPositionAtLastLayout();
1984 }
1985
1986 bool ArgumentCoder<StickyPositionViewportConstraints>::decode(Decoder& decoder, StickyPositionViewportConstraints& viewportConstraints)
1987 {
1988     FloatSize alignmentOffset;
1989     if (!decoder.decode(alignmentOffset))
1990         return false;
1991
1992     ViewportConstraints::AnchorEdges anchorEdges;
1993     if (!decoder.decode(anchorEdges))
1994         return false;
1995
1996     float leftOffset;
1997     if (!decoder.decode(leftOffset))
1998         return false;
1999
2000     float rightOffset;
2001     if (!decoder.decode(rightOffset))
2002         return false;
2003
2004     float topOffset;
2005     if (!decoder.decode(topOffset))
2006         return false;
2007
2008     float bottomOffset;
2009     if (!decoder.decode(bottomOffset))
2010         return false;
2011
2012     FloatRect constrainingRectAtLastLayout;
2013     if (!decoder.decode(constrainingRectAtLastLayout))
2014         return false;
2015
2016     FloatRect containingBlockRect;
2017     if (!decoder.decode(containingBlockRect))
2018         return false;
2019
2020     FloatRect stickyBoxRect;
2021     if (!decoder.decode(stickyBoxRect))
2022         return false;
2023
2024     FloatSize stickyOffsetAtLastLayout;
2025     if (!decoder.decode(stickyOffsetAtLastLayout))
2026         return false;
2027
2028     FloatPoint layerPositionAtLastLayout;
2029     if (!decoder.decode(layerPositionAtLastLayout))
2030         return false;
2031
2032     viewportConstraints = StickyPositionViewportConstraints();
2033     viewportConstraints.setAlignmentOffset(alignmentOffset);
2034     viewportConstraints.setAnchorEdges(anchorEdges);
2035
2036     viewportConstraints.setLeftOffset(leftOffset);
2037     viewportConstraints.setRightOffset(rightOffset);
2038     viewportConstraints.setTopOffset(topOffset);
2039     viewportConstraints.setBottomOffset(bottomOffset);
2040
2041     viewportConstraints.setConstrainingRectAtLastLayout(constrainingRectAtLastLayout);
2042     viewportConstraints.setContainingBlockRect(containingBlockRect);
2043     viewportConstraints.setStickyBoxRect(stickyBoxRect);
2044
2045     viewportConstraints.setStickyOffsetAtLastLayout(stickyOffsetAtLastLayout);
2046     viewportConstraints.setLayerPositionAtLastLayout(layerPositionAtLastLayout);
2047
2048     return true;
2049 }
2050
2051 #if !USE(COORDINATED_GRAPHICS)
2052 void ArgumentCoder<FilterOperation>::encode(Encoder& encoder, const FilterOperation& filter)
2053 {
2054     encoder.encodeEnum(filter.type());
2055
2056     switch (filter.type()) {
2057     case FilterOperation::NONE:
2058     case FilterOperation::REFERENCE:
2059         ASSERT_NOT_REACHED();
2060         break;
2061     case FilterOperation::GRAYSCALE:
2062     case FilterOperation::SEPIA:
2063     case FilterOperation::SATURATE:
2064     case FilterOperation::HUE_ROTATE:
2065         encoder << downcast<BasicColorMatrixFilterOperation>(filter).amount();
2066         break;
2067     case FilterOperation::INVERT:
2068     case FilterOperation::OPACITY:
2069     case FilterOperation::BRIGHTNESS:
2070     case FilterOperation::CONTRAST:
2071         encoder << downcast<BasicComponentTransferFilterOperation>(filter).amount();
2072         break;
2073     case FilterOperation::BLUR:
2074         encoder << downcast<BlurFilterOperation>(filter).stdDeviation();
2075         break;
2076     case FilterOperation::DROP_SHADOW: {
2077         const auto& dropShadowFilter = downcast<DropShadowFilterOperation>(filter);
2078         encoder << dropShadowFilter.location();
2079         encoder << dropShadowFilter.stdDeviation();
2080         encoder << dropShadowFilter.color();
2081         break;
2082     }
2083     case FilterOperation::DEFAULT:
2084         encoder.encodeEnum(downcast<DefaultFilterOperation>(filter).representedType());
2085         break;
2086     case FilterOperation::PASSTHROUGH:
2087         break;
2088     }
2089 }
2090
2091 bool decodeFilterOperation(Decoder& decoder, RefPtr<FilterOperation>& filter)
2092 {
2093     FilterOperation::OperationType type;
2094     if (!decoder.decodeEnum(type))
2095         return false;
2096
2097     switch (type) {
2098     case FilterOperation::NONE:
2099     case FilterOperation::REFERENCE:
2100         ASSERT_NOT_REACHED();
2101         decoder.markInvalid();
2102         return false;
2103     case FilterOperation::GRAYSCALE:
2104     case FilterOperation::SEPIA:
2105     case FilterOperation::SATURATE:
2106     case FilterOperation::HUE_ROTATE: {
2107         double amount;
2108         if (!decoder.decode(amount))
2109             return false;
2110         filter = BasicColorMatrixFilterOperation::create(amount, type);
2111         break;
2112     }
2113     case FilterOperation::INVERT:
2114     case FilterOperation::OPACITY:
2115     case FilterOperation::BRIGHTNESS:
2116     case FilterOperation::CONTRAST: {
2117         double amount;
2118         if (!decoder.decode(amount))
2119             return false;
2120         filter = BasicComponentTransferFilterOperation::create(amount, type);
2121         break;
2122     }
2123     case FilterOperation::BLUR: {
2124         Length stdDeviation;
2125         if (!decoder.decode(stdDeviation))
2126             return false;
2127         filter = BlurFilterOperation::create(stdDeviation);
2128         break;
2129     }
2130     case FilterOperation::DROP_SHADOW: {
2131         IntPoint location;
2132         int stdDeviation;
2133         Color color;
2134         if (!decoder.decode(location))
2135             return false;
2136         if (!decoder.decode(stdDeviation))
2137             return false;
2138         if (!decoder.decode(color))
2139             return false;
2140         filter = DropShadowFilterOperation::create(location, stdDeviation, color);
2141         break;
2142     }
2143     case FilterOperation::DEFAULT: {
2144         FilterOperation::OperationType representedType;
2145         if (!decoder.decodeEnum(representedType))
2146             return false;
2147         filter = DefaultFilterOperation::create(representedType);
2148         break;
2149     }
2150     case FilterOperation::PASSTHROUGH:
2151         filter = PassthroughFilterOperation::create();
2152         break;
2153     }
2154
2155     return true;
2156 }
2157
2158
2159 void ArgumentCoder<FilterOperations>::encode(Encoder& encoder, const FilterOperations& filters)
2160 {
2161     encoder << static_cast<uint64_t>(filters.size());
2162
2163     for (const auto& filter : filters.operations())
2164         encoder << *filter;
2165 }
2166
2167 bool ArgumentCoder<FilterOperations>::decode(Decoder& decoder, FilterOperations& filters)
2168 {
2169     uint64_t filterCount;
2170     if (!decoder.decode(filterCount))
2171         return false;
2172
2173     for (uint64_t i = 0; i < filterCount; ++i) {
2174         RefPtr<FilterOperation> filter;
2175         if (!decodeFilterOperation(decoder, filter))
2176             return false;
2177         filters.operations().append(WTFMove(filter));
2178     }
2179
2180     return true;
2181 }
2182 #endif // !USE(COORDINATED_GRAPHICS)
2183
2184 void ArgumentCoder<BlobPart>::encode(Encoder& encoder, const BlobPart& blobPart)
2185 {
2186     encoder << static_cast<uint32_t>(blobPart.type());
2187     switch (blobPart.type()) {
2188     case BlobPart::Data:
2189         encoder << blobPart.data();
2190         break;
2191     case BlobPart::Blob:
2192         encoder << blobPart.url();
2193         break;
2194     }
2195 }
2196
2197 bool ArgumentCoder<BlobPart>::decode(Decoder& decoder, BlobPart& blobPart)
2198 {
2199     uint32_t type;
2200     if (!decoder.decode(type))
2201         return false;
2202
2203     switch (type) {
2204     case BlobPart::Data: {
2205         Vector<uint8_t> data;
2206         if (!decoder.decode(data))
2207             return false;
2208         blobPart = BlobPart(WTFMove(data));
2209         break;
2210     }
2211     case BlobPart::Blob: {
2212         URL url;
2213         if (!decoder.decode(url))
2214             return false;
2215         blobPart = BlobPart(url);
2216         break;
2217     }
2218     default:
2219         return false;
2220     }
2221
2222     return true;
2223 }
2224
2225 void ArgumentCoder<TextIndicatorData>::encode(Encoder& encoder, const TextIndicatorData& textIndicatorData)
2226 {
2227     encoder << textIndicatorData.selectionRectInRootViewCoordinates;
2228     encoder << textIndicatorData.textBoundingRectInRootViewCoordinates;
2229     encoder << textIndicatorData.textRectsInBoundingRectCoordinates;
2230     encoder << textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates;
2231     encoder << textIndicatorData.contentImageScaleFactor;
2232     encoder << textIndicatorData.estimatedBackgroundColor;
2233     encoder.encodeEnum(textIndicatorData.presentationTransition);
2234     encoder << static_cast<uint64_t>(textIndicatorData.options);
2235
2236     encodeOptionalImage(encoder, textIndicatorData.contentImage.get());
2237     encodeOptionalImage(encoder, textIndicatorData.contentImageWithHighlight.get());
2238     encodeOptionalImage(encoder, textIndicatorData.contentImageWithoutSelection.get());
2239 }
2240
2241 bool ArgumentCoder<TextIndicatorData>::decode(Decoder& decoder, TextIndicatorData& textIndicatorData)
2242 {
2243     if (!decoder.decode(textIndicatorData.selectionRectInRootViewCoordinates))
2244         return false;
2245
2246     if (!decoder.decode(textIndicatorData.textBoundingRectInRootViewCoordinates))
2247         return false;
2248
2249     if (!decoder.decode(textIndicatorData.textRectsInBoundingRectCoordinates))
2250         return false;
2251
2252     if (!decoder.decode(textIndicatorData.contentImageWithoutSelectionRectInRootViewCoordinates))
2253         return false;
2254
2255     if (!decoder.decode(textIndicatorData.contentImageScaleFactor))
2256         return false;
2257
2258     if (!decoder.decode(textIndicatorData.estimatedBackgroundColor))
2259         return false;
2260
2261     if (!decoder.decodeEnum(textIndicatorData.presentationTransition))
2262         return false;
2263
2264     uint64_t options;
2265     if (!decoder.decode(options))
2266         return false;
2267     textIndicatorData.options = static_cast<TextIndicatorOptions>(options);
2268
2269     if (!decodeOptionalImage(decoder, textIndicatorData.contentImage))
2270         return false;
2271
2272     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithHighlight))
2273         return false;
2274
2275     if (!decodeOptionalImage(decoder, textIndicatorData.contentImageWithoutSelection))
2276         return false;
2277
2278     return true;
2279 }
2280
2281 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
2282 void ArgumentCoder<MediaPlaybackTargetContext>::encode(Encoder& encoder, const MediaPlaybackTargetContext& target)
2283 {
2284     bool hasPlatformData = target.encodingRequiresPlatformData();
2285     encoder << hasPlatformData;
2286
2287     int32_t targetType = target.type();
2288     encoder << targetType;
2289
2290     if (target.encodingRequiresPlatformData()) {
2291         encodePlatformData(encoder, target);
2292         return;
2293     }
2294
2295     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2296     encoder << target.mockDeviceName();
2297     encoder << static_cast<int32_t>(target.mockState());
2298 }
2299
2300 bool ArgumentCoder<MediaPlaybackTargetContext>::decode(Decoder& decoder, MediaPlaybackTargetContext& target)
2301 {
2302     bool hasPlatformData;
2303     if (!decoder.decode(hasPlatformData))
2304         return false;
2305
2306     int32_t targetType;
2307     if (!decoder.decode(targetType))
2308         return false;
2309
2310     if (hasPlatformData)
2311         return decodePlatformData(decoder, target);
2312
2313     ASSERT(targetType == MediaPlaybackTargetContext::MockType);
2314
2315     String mockDeviceName;
2316     if (!decoder.decode(mockDeviceName))
2317         return false;
2318
2319     int32_t mockState;
2320     if (!decoder.decode(mockState))
2321         return false;
2322
2323     target = MediaPlaybackTargetContext(mockDeviceName, static_cast<MediaPlaybackTargetContext::State>(mockState));
2324     return true;
2325 }
2326 #endif
2327
2328 void ArgumentCoder<DictionaryPopupInfo>::encode(IPC::Encoder& encoder, const DictionaryPopupInfo& info)
2329 {
2330     encoder << info.origin;
2331     encoder << info.textIndicator;
2332
2333 #if PLATFORM(COCOA)
2334     bool hadOptions = info.options;
2335     encoder << hadOptions;
2336     if (hadOptions)
2337         IPC::encode(encoder, info.options.get());
2338
2339     bool hadAttributedString = info.attributedString;
2340     encoder << hadAttributedString;
2341     if (hadAttributedString)
2342         IPC::encode(encoder, info.attributedString.get());
2343 #endif
2344 }
2345
2346 bool ArgumentCoder<DictionaryPopupInfo>::decode(IPC::Decoder& decoder, DictionaryPopupInfo& result)
2347 {
2348     if (!decoder.decode(result.origin))
2349         return false;
2350
2351     if (!decoder.decode(result.textIndicator))
2352         return false;
2353
2354 #if PLATFORM(COCOA)
2355     bool hadOptions;
2356     if (!decoder.decode(hadOptions))
2357         return false;
2358     if (hadOptions) {
2359         if (!IPC::decode(decoder, result.options))
2360             return false;
2361     } else
2362         result.options = nullptr;
2363
2364     bool hadAttributedString;
2365     if (!decoder.decode(hadAttributedString))
2366         return false;
2367     if (hadAttributedString) {
2368         if (!IPC::decode(decoder, result.attributedString))
2369             return false;
2370     } else
2371         result.attributedString = nullptr;
2372 #endif
2373     return true;
2374 }
2375
2376 void ArgumentCoder<ExceptionDetails>::encode(IPC::Encoder& encoder, const ExceptionDetails& info)
2377 {
2378     encoder << info.message;
2379     encoder << info.lineNumber;
2380     encoder << info.columnNumber;
2381     encoder << info.sourceURL;
2382 }
2383
2384 bool ArgumentCoder<ExceptionDetails>::decode(IPC::Decoder& decoder, ExceptionDetails& result)
2385 {
2386     if (!decoder.decode(result.message))
2387         return false;
2388
2389     if (!decoder.decode(result.lineNumber))
2390         return false;
2391
2392     if (!decoder.decode(result.columnNumber))
2393         return false;
2394
2395     if (!decoder.decode(result.sourceURL))
2396         return false;
2397
2398     return true;
2399 }
2400
2401 void ArgumentCoder<ResourceLoadStatistics>::encode(Encoder& encoder, const WebCore::ResourceLoadStatistics& statistics)
2402 {
2403     encoder << statistics.highLevelDomain;
2404
2405     encoder << statistics.lastSeen.secondsSinceEpoch().value();
2406
2407     // User interaction
2408     encoder << statistics.hadUserInteraction;
2409     encoder << statistics.mostRecentUserInteractionTime.secondsSinceEpoch().value();
2410     encoder << statistics.grandfathered;
2411
2412     // Subframe stats
2413     encoder << statistics.subframeUnderTopFrameOrigins;
2414
2415     // Subresource stats
2416     encoder << statistics.subresourceUnderTopFrameOrigins;
2417     encoder << statistics.subresourceUniqueRedirectsTo;
2418
2419     // Prevalent Resource
2420     encoder << statistics.isPrevalentResource;
2421     encoder << statistics.dataRecordsRemoved;
2422 }
2423
2424 bool ArgumentCoder<ResourceLoadStatistics>::decode(Decoder& decoder, WebCore::ResourceLoadStatistics& statistics)
2425 {
2426     if (!decoder.decode(statistics.highLevelDomain))
2427         return false;
2428
2429     double lastSeenTimeAsDouble;
2430     if (!decoder.decode(lastSeenTimeAsDouble))
2431         return false;
2432     statistics.lastSeen = WallTime::fromRawSeconds(lastSeenTimeAsDouble);
2433
2434     // User interaction
2435     if (!decoder.decode(statistics.hadUserInteraction))
2436         return false;
2437
2438     double mostRecentUserInteractionTimeAsDouble;
2439     if (!decoder.decode(mostRecentUserInteractionTimeAsDouble))
2440         return false;
2441     statistics.mostRecentUserInteractionTime = WallTime::fromRawSeconds(mostRecentUserInteractionTimeAsDouble);
2442
2443     if (!decoder.decode(statistics.grandfathered))
2444         return false;
2445
2446     // Subframe stats
2447     if (!decoder.decode(statistics.subframeUnderTopFrameOrigins))
2448         return false;
2449
2450     // Subresource stats
2451     if (!decoder.decode(statistics.subresourceUnderTopFrameOrigins))
2452         return false;
2453
2454     if (!decoder.decode(statistics.subresourceUniqueRedirectsTo))
2455         return false;
2456
2457     // Prevalent Resource
2458     if (!decoder.decode(statistics.isPrevalentResource))
2459         return false;
2460
2461     if (!decoder.decode(statistics.dataRecordsRemoved))
2462         return false;
2463
2464     return true;
2465 }
2466
2467 #if ENABLE(MEDIA_STREAM)
2468 void ArgumentCoder<MediaConstraints>::encode(Encoder& encoder, const WebCore::MediaConstraints& constraint)
2469 {
2470     encoder << constraint.mandatoryConstraints
2471         << constraint.advancedConstraints
2472         << constraint.deviceIDHashSalt
2473         << constraint.isValid;
2474 }
2475
2476 bool ArgumentCoder<MediaConstraints>::decode(Decoder& decoder, WebCore::MediaConstraints& constraints)
2477 {
2478     return decoder.decode(constraints.mandatoryConstraints)
2479         && decoder.decode(constraints.advancedConstraints)
2480         && decoder.decode(constraints.deviceIDHashSalt)
2481         && decoder.decode(constraints.isValid);
2482 }
2483
2484 void ArgumentCoder<CaptureDevice>::encode(Encoder& encoder, const WebCore::CaptureDevice& device)
2485 {
2486     encoder << device.persistentId();
2487     encoder << device.label();
2488     encoder << device.groupId();
2489     encoder << device.enabled();
2490     encoder.encodeEnum(device.type());
2491 }
2492
2493 bool ArgumentCoder<CaptureDevice>::decode(Decoder& decoder, WebCore::CaptureDevice& device)
2494 {
2495     String persistentId;
2496     if (!decoder.decode(persistentId))
2497         return false;
2498
2499     String label;
2500     if (!decoder.decode(label))
2501         return false;
2502
2503     String groupId;
2504     if (!decoder.decode(groupId))
2505         return false;
2506
2507     bool enabled;
2508     if (!decoder.decode(enabled))
2509         return false;
2510
2511     CaptureDevice::DeviceType type;
2512     if (!decoder.decodeEnum(type))
2513         return false;
2514
2515     device.setPersistentId(persistentId);
2516     device.setLabel(label);
2517     device.setGroupId(groupId);
2518     device.setType(type);
2519     device.setEnabled(enabled);
2520
2521     return true;
2522 }
2523 #endif
2524
2525 #if ENABLE(INDEXED_DATABASE)
2526 void ArgumentCoder<IDBKeyPath>::encode(Encoder& encoder, const IDBKeyPath& keyPath)
2527 {
2528     bool isString = WTF::holds_alternative<String>(keyPath);
2529     encoder << isString;
2530     if (isString)
2531         encoder << WTF::get<String>(keyPath);
2532     else
2533         encoder << WTF::get<Vector<String>>(keyPath);
2534 }
2535
2536 bool ArgumentCoder<IDBKeyPath>::decode(Decoder& decoder, IDBKeyPath& keyPath)
2537 {
2538     bool isString;
2539     if (!decoder.decode(isString))
2540         return false;
2541     if (isString) {
2542         String string;
2543         if (!decoder.decode(string))
2544             return false;
2545         keyPath = string;
2546     } else {
2547         Vector<String> vector;
2548         if (!decoder.decode(vector))
2549             return false;
2550         keyPath = vector;
2551     }
2552     return true;
2553 }
2554 #endif
2555
2556 #if ENABLE(CSS_SCROLL_SNAP)
2557
2558 void ArgumentCoder<ScrollOffsetRange<float>>::encode(Encoder& encoder, const ScrollOffsetRange<float>& range)
2559 {
2560     encoder << range.start;
2561     encoder << range.end;
2562 }
2563
2564 bool ArgumentCoder<ScrollOffsetRange<float>>::decode(Decoder& decoder, ScrollOffsetRange<float>& range)
2565 {
2566     float start;
2567     if (!decoder.decode(start))
2568         return false;
2569
2570     float end;
2571     if (!decoder.decode(end))
2572         return false;
2573
2574     range.start = start;
2575     range.end = end;
2576     return true;
2577 }
2578
2579 #endif
2580
2581 void ArgumentCoder<MediaSelectionOption>::encode(Encoder& encoder, const MediaSelectionOption& option)
2582 {
2583     encoder << option.displayName;
2584     encoder << option.type;
2585 }
2586
2587 bool ArgumentCoder<MediaSelectionOption>::decode(Decoder& decoder, MediaSelectionOption& option)
2588 {
2589     if (!decoder.decode(option.displayName))
2590         return false;
2591
2592     if (!decoder.decode(option.type))
2593         return false;
2594
2595     return true;
2596 }
2597
2598 } // namespace IPC