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 "ShareableBitmap.h"
  30 #include <WebCore/AuthenticationChallenge.h>
  31 #include <WebCore/Cookie.h>
  32 #include <WebCore/Credential.h>
  33 #include <WebCore/Cursor.h>
  34 #include <WebCore/DatabaseDetails.h>
  35 #include <WebCore/DictationAlternative.h>
  36 #include <WebCore/DragSession.h>
  37 #include <WebCore/Editor.h>
  38 #include <WebCore/FileChooser.h>
  39 #include <WebCore/GraphicsContext.h>
  40 #include <WebCore/GraphicsLayer.h>
  41 #include <WebCore/Image.h>
  42 #include <WebCore/KURL.h>
  43 #include <WebCore/PluginData.h>
  44 #include <WebCore/ProtectionSpace.h>
  45 #include <WebCore/ResourceError.h>
  46 #include <WebCore/ResourceRequest.h>
  47 #include <WebCore/ResourceResponse.h>
  48 #include <WebCore/TextCheckerClient.h>
  49 #include <WebCore/UserScript.h>
  50 #include <WebCore/UserStyleSheet.h>
  51 #include <WebCore/ViewportArguments.h>
  52 #include <WebCore/WindowFeatures.h>
  53 #include <wtf/text/StringHash.h>
  54
  55 using namespace WebCore;
  56 using namespace WebKit;
  57
  58 namespace CoreIPC {
  59
  60 void ArgumentCoder<AffineTransform>::encode(ArgumentEncoder& encoder, const AffineTransform& affineTransform)
  61 {
  62     SimpleArgumentCoder<AffineTransform>::encode(encoder, affineTransform);
  63 }
  64
  65 bool ArgumentCoder<AffineTransform>::decode(ArgumentDecoder* decoder, AffineTransform& affineTransform)
  66 {
  67     return SimpleArgumentCoder<AffineTransform>::decode(decoder, affineTransform);
  68 }
  69
  70
  71 void ArgumentCoder<FloatPoint>::encode(ArgumentEncoder& encoder, const FloatPoint& floatPoint)
  72 {
  73     SimpleArgumentCoder<FloatPoint>::encode(encoder, floatPoint);
  74 }
  75
  76 bool ArgumentCoder<FloatPoint>::decode(ArgumentDecoder* decoder, FloatPoint& floatPoint)
  77 {
  78     return SimpleArgumentCoder<FloatPoint>::decode(decoder, floatPoint);
  79 }
  80
  81
  82 void ArgumentCoder<FloatRect>::encode(ArgumentEncoder& encoder, const FloatRect& floatRect)
  83 {
  84     SimpleArgumentCoder<FloatRect>::encode(encoder, floatRect);
  85 }
  86
  87 bool ArgumentCoder<FloatRect>::decode(ArgumentDecoder* decoder, FloatRect& floatRect)
  88 {
  89     return SimpleArgumentCoder<FloatRect>::decode(decoder, floatRect);
  90 }
  91
  92
  93 void ArgumentCoder<FloatSize>::encode(ArgumentEncoder& encoder, const FloatSize& floatSize)
  94 {
  95     SimpleArgumentCoder<FloatSize>::encode(encoder, floatSize);
  96 }
  97
  98 bool ArgumentCoder<FloatSize>::decode(ArgumentDecoder* decoder, FloatSize& floatSize)
  99 {
 100     return SimpleArgumentCoder<FloatSize>::decode(decoder, floatSize);
 101 }
 102
 103
 104 void ArgumentCoder<IntPoint>::encode(ArgumentEncoder& encoder, const IntPoint& intPoint)
 105 {
 106     SimpleArgumentCoder<IntPoint>::encode(encoder, intPoint);
 107 }
 108
 109 bool ArgumentCoder<IntPoint>::decode(ArgumentDecoder* decoder, IntPoint& intPoint)
 110 {
 111     return SimpleArgumentCoder<IntPoint>::decode(decoder, intPoint);
 112 }
 113
 114
 115 void ArgumentCoder<IntRect>::encode(ArgumentEncoder& encoder, const IntRect& intRect)
 116 {
 117     SimpleArgumentCoder<IntRect>::encode(encoder, intRect);
 118 }
 119
 120 bool ArgumentCoder<IntRect>::decode(ArgumentDecoder* decoder, IntRect& intRect)
 121 {
 122     return SimpleArgumentCoder<IntRect>::decode(decoder, intRect);
 123 }
 124
 125
 126 void ArgumentCoder<IntSize>::encode(ArgumentEncoder& encoder, const IntSize& intSize)
 127 {
 128     SimpleArgumentCoder<IntSize>::encode(encoder, intSize);
 129 }
 130
 131 bool ArgumentCoder<IntSize>::decode(ArgumentDecoder* decoder, IntSize& intSize)
 132 {
 133     return SimpleArgumentCoder<IntSize>::decode(decoder, intSize);
 134 }
 135
 136
 137 void ArgumentCoder<ViewportAttributes>::encode(ArgumentEncoder& encoder, const ViewportAttributes& viewportAttributes)
 138 {
 139     SimpleArgumentCoder<ViewportAttributes>::encode(encoder, viewportAttributes);
 140 }
 141
 142 bool ArgumentCoder<ViewportAttributes>::decode(ArgumentDecoder* decoder, ViewportAttributes& viewportAttributes)
 143 {
 144     return SimpleArgumentCoder<ViewportAttributes>::decode(decoder, viewportAttributes);
 145 }
 146
 147
 148 void ArgumentCoder<MimeClassInfo>::encode(ArgumentEncoder& encoder, const MimeClassInfo& mimeClassInfo)
 149 {
 150     encoder << mimeClassInfo.type << mimeClassInfo.desc << mimeClassInfo.extensions;
 151 }
 152
 153 bool ArgumentCoder<MimeClassInfo>::decode(ArgumentDecoder* decoder, MimeClassInfo& mimeClassInfo)
 154 {
 155     if (!decoder->decode(mimeClassInfo.type))
 156         return false;
 157     if (!decoder->decode(mimeClassInfo.desc))
 158         return false;
 159     if (!decoder->decode(mimeClassInfo.extensions))
 160         return false;
 161
 162     return true;
 163 }
 164
 165
 166 void ArgumentCoder<PluginInfo>::encode(ArgumentEncoder& encoder, const PluginInfo& pluginInfo)
 167 {
 168     encoder << pluginInfo.name << pluginInfo.file << pluginInfo.desc << pluginInfo.mimes;
 169 }
 170
 171 bool ArgumentCoder<PluginInfo>::decode(ArgumentDecoder* decoder, PluginInfo& pluginInfo)
 172 {
 173     if (!decoder->decode(pluginInfo.name))
 174         return false;
 175     if (!decoder->decode(pluginInfo.file))
 176         return false;
 177     if (!decoder->decode(pluginInfo.desc))
 178         return false;
 179     if (!decoder->decode(pluginInfo.mimes))
 180         return false;
 181
 182     return true;
 183 }
 184
 185
 186 void ArgumentCoder<HTTPHeaderMap>::encode(ArgumentEncoder& encoder, const HTTPHeaderMap& headerMap)
 187 {
 188     encoder << static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap);
 189 }
 190
 191 bool ArgumentCoder<HTTPHeaderMap>::decode(ArgumentDecoder* decoder, HTTPHeaderMap& headerMap)
 192 {
 193     return decoder->decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
 194 }
 195
 196
 197 void ArgumentCoder<AuthenticationChallenge>::encode(ArgumentEncoder& encoder, const AuthenticationChallenge& challenge)
 198 {
 199     encoder << challenge.protectionSpace() << challenge.proposedCredential() << challenge.previousFailureCount() << challenge.failureResponse() << challenge.error();
 200 }
 201
 202 bool ArgumentCoder<AuthenticationChallenge>::decode(ArgumentDecoder* decoder, AuthenticationChallenge& challenge)
 203 {
 204     ProtectionSpace protectionSpace;
 205     if (!decoder->decode(protectionSpace))
 206         return false;
 207
 208     Credential proposedCredential;
 209     if (!decoder->decode(proposedCredential))
 210         return false;
 211
 212     unsigned previousFailureCount;
 213     if (!decoder->decode(previousFailureCount))
 214         return false;
 215
 216     ResourceResponse failureResponse;
 217     if (!decoder->decode(failureResponse))
 218         return false;
 219
 220     ResourceError error;
 221     if (!decoder->decode(error))
 222         return false;
 223
 224     challenge = AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
 225     return true;
 226 }
 227
 228
 229 void ArgumentCoder<ProtectionSpace>::encode(ArgumentEncoder& encoder, const ProtectionSpace& space)
 230 {
 231     encoder << space.host() << space.port() << space.realm();
 232     encoder.encodeEnum(space.authenticationScheme());
 233     encoder.encodeEnum(space.serverType());
 234 }
 235
 236 bool ArgumentCoder<ProtectionSpace>::decode(ArgumentDecoder* decoder, ProtectionSpace& space)
 237 {
 238     String host;
 239     if (!decoder->decode(host))
 240         return false;
 241
 242     int port;
 243     if (!decoder->decode(port))
 244         return false;
 245
 246     String realm;
 247     if (!decoder->decode(realm))
 248         return false;
 249
 250     ProtectionSpaceAuthenticationScheme authenticationScheme;
 251     if (!decoder->decodeEnum(authenticationScheme))
 252         return false;
 253
 254     ProtectionSpaceServerType serverType;
 255     if (!decoder->decodeEnum(serverType))
 256         return false;
 257
 258     space = ProtectionSpace(host, port, serverType, realm, authenticationScheme);
 259     return true;
 260 }
 261
 262 void ArgumentCoder<Credential>::encode(ArgumentEncoder& encoder, const Credential& credential)
 263 {
 264     encoder << credential.user() << credential.password();
 265     encoder.encodeEnum(credential.persistence());
 266 }
 267
 268 bool ArgumentCoder<Credential>::decode(ArgumentDecoder* decoder, Credential& credential)
 269 {
 270     String user;
 271     if (!decoder->decode(user))
 272         return false;
 273
 274     String password;
 275     if (!decoder->decode(password))
 276         return false;
 277
 278     CredentialPersistence persistence;
 279     if (!decoder->decodeEnum(persistence))
 280         return false;
 281
 282     credential = Credential(user, password, persistence);
 283     return true;
 284 }
 285
 286 static void encodeImage(ArgumentEncoder& encoder, Image* image)
 287 {
 288     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(image->size(), ShareableBitmap::SupportsAlpha);
 289     bitmap->createGraphicsContext()->drawImage(image, ColorSpaceDeviceRGB, IntPoint());
 290
 291     ShareableBitmap::Handle handle;
 292     bitmap->createHandle(handle);
 293
 294     encoder << handle;
 295 }
 296
 297 static bool decodeImage(ArgumentDecoder* decoder, RefPtr<Image>& image)
 298 {
 299     ShareableBitmap::Handle handle;
 300     if (!decoder->decode(handle))
 301         return false;
 302
 303     RefPtr<ShareableBitmap> bitmap = ShareableBitmap::create(handle);
 304     if (!bitmap)
 305         return false;
 306     image = bitmap->createImage();
 307     if (!image)
 308         return false;
 309     return true;
 310 }
 311
 312 void ArgumentCoder<Cursor>::encode(ArgumentEncoder& encoder, const Cursor& cursor)
 313 {
 314     encoder.encodeEnum(cursor.type());
 315
 316     if (cursor.type() != Cursor::Custom)
 317         return;
 318
 319     if (cursor.image()->isNull()) {
 320         encoder << false; // There is no valid image being encoded.
 321         return;
 322     }
 323
 324     encoder << true;
 325     encodeImage(encoder, cursor.image());
 326     encoder << cursor.hotSpot();
 327 }
 328
 329 bool ArgumentCoder<Cursor>::decode(ArgumentDecoder* decoder, Cursor& cursor)
 330 {
 331     Cursor::Type type;
 332     if (!decoder->decodeEnum(type))
 333         return false;
 334
 335     if (type > Cursor::Custom)
 336         return false;
 337
 338     if (type != Cursor::Custom) {
 339         const Cursor& cursorReference = Cursor::fromType(type);
 340         // Calling platformCursor here will eagerly create the platform cursor for the cursor singletons inside WebCore.
 341         // This will avoid having to re-create the platform cursors over and over.
 342         (void)cursorReference.platformCursor();
 343
 344         cursor = cursorReference;
 345         return true;
 346     }
 347
 348     bool isValidImagePresent;
 349     if (!decoder->decode(isValidImagePresent))
 350         return false;
 351
 352     if (!isValidImagePresent) {
 353         cursor = Cursor(Image::nullImage(), IntPoint());
 354         return true;
 355     }
 356
 357     RefPtr<Image> image;
 358     if (!decodeImage(decoder, image))
 359         return false;
 360
 361     IntPoint hotSpot;
 362     if (!decoder->decode(hotSpot))
 363         return false;
 364
 365     if (!image->rect().contains(hotSpot))
 366         return false;
 367
 368     cursor = Cursor(image.get(), hotSpot);
 369     return true;
 370 }
 371
 372 void ArgumentCoder<ResourceRequest>::encode(ArgumentEncoder& encoder, const ResourceRequest& resourceRequest)
 373 {
 374     if (kShouldSerializeWebCoreData) {
 375         encoder << resourceRequest.url().string();
 376         encoder << resourceRequest.httpMethod();
 377         encoder << resourceRequest.httpHeaderFields();
 378
 379         // FIXME: Do not encode HTTP message body.
 380         // 1. It can be large and thus costly to send across.
 381         // 2. It is misleading to provide a body with some requests, while others use body streams, which cannot be serialized at all.
 382         FormData* httpBody = resourceRequest.httpBody();
 383         encoder << static_cast<bool>(httpBody);
 384         if (httpBody)
 385             encoder << httpBody->flattenToString();
 386
 387         encoder << resourceRequest.firstPartyForCookies().string();
 388     }
 389
 390     encodePlatformData(encoder, resourceRequest);
 391 }
 392
 393 bool ArgumentCoder<ResourceRequest>::decode(ArgumentDecoder* decoder, ResourceRequest& resourceRequest)
 394 {
 395     if (kShouldSerializeWebCoreData) {
 396         ResourceRequest request;
 397
 398         String url;
 399         if (!decoder->decode(url))
 400             return false;
 401         request.setURL(KURL(KURL(), url));
 402
 403         String httpMethod;
 404         if (!decoder->decode(httpMethod))
 405             return false;
 406         request.setHTTPMethod(httpMethod);
 407
 408         HTTPHeaderMap headers;
 409         if (!decoder->decode(headers))
 410             return false;
 411         request.addHTTPHeaderFields(headers);
 412
 413         bool hasHTTPBody;
 414         if (!decoder->decode(hasHTTPBody))
 415             return false;
 416         if (hasHTTPBody) {
 417             String httpBody;
 418             if (!decoder->decode(httpBody))
 419                 return false;
 420             request.setHTTPBody(FormData::create(httpBody.utf8()));
 421         }
 422
 423         String firstPartyForCookies;
 424         if (!decoder->decode(firstPartyForCookies))
 425             return false;
 426         request.setFirstPartyForCookies(KURL(KURL(), firstPartyForCookies));
 427
 428         resourceRequest = request;
 429     }
 430
 431     return decodePlatformData(decoder, resourceRequest);
 432 }
 433
 434 void ArgumentCoder<ResourceResponse>::encode(ArgumentEncoder& encoder, const ResourceResponse& resourceResponse)
 435 {
 436     if (kShouldSerializeWebCoreData) {
 437         bool responseIsNull = resourceResponse.isNull();
 438         encoder << responseIsNull;
 439         if (responseIsNull)
 440             return;
 441
 442         encoder << resourceResponse.url().string();
 443         encoder << static_cast<int32_t>(resourceResponse.httpStatusCode());
 444         encoder << resourceResponse.httpHeaderFields();
 445
 446         encoder << resourceResponse.mimeType();
 447         encoder << resourceResponse.textEncodingName();
 448         encoder << static_cast<int64_t>(resourceResponse.expectedContentLength());
 449         encoder << resourceResponse.httpStatusText();
 450         encoder << resourceResponse.suggestedFilename();
 451     }
 452
 453     encodePlatformData(encoder, resourceResponse);
 454 }
 455
 456 bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
 457 {
 458     if (kShouldSerializeWebCoreData) {
 459         bool responseIsNull;
 460         if (!decoder->decode(responseIsNull))
 461             return false;
 462         if (responseIsNull) {
 463             resourceResponse = ResourceResponse();
 464             return true;
 465         }
 466
 467         ResourceResponse response;
 468
 469         String url;
 470         if (!decoder->decode(url))
 471             return false;
 472         response.setURL(KURL(KURL(), url));
 473
 474         int32_t httpStatusCode;
 475         if (!decoder->decode(httpStatusCode))
 476             return false;
 477         response.setHTTPStatusCode(httpStatusCode);
 478
 479         HTTPHeaderMap headers;
 480         if (!decoder->decode(headers))
 481             return false;
 482         for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
 483             response.setHTTPHeaderField(it->key, it->value);
 484
 485         String mimeType;
 486         if (!decoder->decode(mimeType))
 487             return false;
 488         response.setMimeType(mimeType);
 489
 490         String textEncodingName;
 491         if (!decoder->decode(textEncodingName))
 492             return false;
 493         response.setTextEncodingName(textEncodingName);
 494
 495         int64_t contentLength;
 496         if (!decoder->decode(contentLength))
 497             return false;
 498         response.setExpectedContentLength(contentLength);
 499
 500         String httpStatusText;
 501         if (!decoder->decode(httpStatusText))
 502             return false;
 503         response.setHTTPStatusText(httpStatusText);
 504
 505         String suggestedFilename;
 506         if (!decoder->decode(suggestedFilename))
 507             return false;
 508         response.setSuggestedFilename(suggestedFilename);
 509
 510         resourceResponse = response;
 511     }
 512
 513     return decodePlatformData(decoder, resourceResponse);
 514 }
 515
 516 void ArgumentCoder<ResourceError>::encode(ArgumentEncoder& encoder, const ResourceError& resourceError)
 517 {
 518     if (kShouldSerializeWebCoreData) {
 519         bool errorIsNull = resourceError.isNull();
 520         encoder << errorIsNull;
 521         if (errorIsNull)
 522             return;
 523
 524         encoder << resourceError.domain();
 525         encoder << resourceError.errorCode();
 526         encoder << resourceError.failingURL();
 527         encoder << resourceError.localizedDescription();
 528         encoder << resourceError.isCancellation();
 529         encoder << resourceError.isTimeout();
 530     }
 531
 532     encodePlatformData(encoder, resourceError);
 533 }
 534
 535 bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder* decoder, ResourceError& resourceError)
 536 {
 537     if (kShouldSerializeWebCoreData) {
 538         bool errorIsNull;
 539         if (!decoder->decode(errorIsNull))
 540             return false;
 541         if (errorIsNull) {
 542             resourceError = ResourceError();
 543             return true;
 544         }
 545
 546         String domain;
 547         if (!decoder->decode(domain))
 548             return false;
 549
 550         int errorCode;
 551         if (!decoder->decode(errorCode))
 552             return false;
 553
 554         String failingURL;
 555         if (!decoder->decode(failingURL))
 556             return false;
 557
 558         String localizedDescription;
 559         if (!decoder->decode(localizedDescription))
 560             return false;
 561
 562         bool isCancellation;
 563         if (!decoder->decode(isCancellation))
 564             return false;
 565
 566         bool isTimeout;
 567         if (!decoder->decode(isTimeout))
 568             return false;
 569
 570         resourceError = ResourceError(domain, errorCode, failingURL, localizedDescription);
 571         resourceError.setIsCancellation(isCancellation);
 572         resourceError.setIsTimeout(isTimeout);
 573     }
 574
 575     return decodePlatformData(decoder, resourceError);
 576 }
 577
 578 void ArgumentCoder<WindowFeatures>::encode(ArgumentEncoder& encoder, const WindowFeatures& windowFeatures)
 579 {
 580     encoder << windowFeatures.x;
 581     encoder << windowFeatures.y;
 582     encoder << windowFeatures.width;
 583     encoder << windowFeatures.height;
 584     encoder << windowFeatures.xSet;
 585     encoder << windowFeatures.ySet;
 586     encoder << windowFeatures.widthSet;
 587     encoder << windowFeatures.heightSet;
 588     encoder << windowFeatures.menuBarVisible;
 589     encoder << windowFeatures.statusBarVisible;
 590     encoder << windowFeatures.toolBarVisible;
 591     encoder << windowFeatures.locationBarVisible;
 592     encoder << windowFeatures.scrollbarsVisible;
 593     encoder << windowFeatures.resizable;
 594     encoder << windowFeatures.fullscreen;
 595     encoder << windowFeatures.dialog;
 596 }
 597
 598 bool ArgumentCoder<WindowFeatures>::decode(ArgumentDecoder* decoder, WindowFeatures& windowFeatures)
 599 {
 600     if (!decoder->decode(windowFeatures.x))
 601         return false;
 602     if (!decoder->decode(windowFeatures.y))
 603         return false;
 604     if (!decoder->decode(windowFeatures.width))
 605         return false;
 606     if (!decoder->decode(windowFeatures.height))
 607         return false;
 608     if (!decoder->decode(windowFeatures.xSet))
 609         return false;
 610     if (!decoder->decode(windowFeatures.ySet))
 611         return false;
 612     if (!decoder->decode(windowFeatures.widthSet))
 613         return false;
 614     if (!decoder->decode(windowFeatures.heightSet))
 615         return false;
 616     if (!decoder->decode(windowFeatures.menuBarVisible))
 617         return false;
 618     if (!decoder->decode(windowFeatures.statusBarVisible))
 619         return false;
 620     if (!decoder->decode(windowFeatures.toolBarVisible))
 621         return false;
 622     if (!decoder->decode(windowFeatures.locationBarVisible))
 623         return false;
 624     if (!decoder->decode(windowFeatures.scrollbarsVisible))
 625         return false;
 626     if (!decoder->decode(windowFeatures.resizable))
 627         return false;
 628     if (!decoder->decode(windowFeatures.fullscreen))
 629         return false;
 630     if (!decoder->decode(windowFeatures.dialog))
 631         return false;
 632     return true;
 633 }
 634
 635
 636 void ArgumentCoder<Color>::encode(ArgumentEncoder& encoder, const Color& color)
 637 {
 638     if (!color.isValid()) {
 639         encoder << false;
 640         return;
 641     }
 642
 643     encoder << true;
 644     encoder << color.rgb();
 645 }
 646
 647 bool ArgumentCoder<Color>::decode(ArgumentDecoder* decoder, Color& color)
 648 {
 649     bool isValid;
 650     if (!decoder->decode(isValid))
 651         return false;
 652
 653     if (!isValid) {
 654         color = Color();
 655         return true;
 656     }
 657
 658     RGBA32 rgba;
 659     if (!decoder->decode(rgba))
 660         return false;
 661
 662     color = Color(rgba);
 663     return true;
 664 }
 665
 666
 667 void ArgumentCoder<CompositionUnderline>::encode(ArgumentEncoder& encoder, const CompositionUnderline& underline)
 668 {
 669     encoder << underline.startOffset;
 670     encoder << underline.endOffset;
 671     encoder << underline.thick;
 672     encoder << underline.color;
 673 }
 674
 675 bool ArgumentCoder<CompositionUnderline>::decode(ArgumentDecoder* decoder, CompositionUnderline& underline)
 676 {
 677     if (!decoder->decode(underline.startOffset))
 678         return false;
 679     if (!decoder->decode(underline.endOffset))
 680         return false;
 681     if (!decoder->decode(underline.thick))
 682         return false;
 683     if (!decoder->decode(underline.color))
 684         return false;
 685
 686     return true;
 687 }
 688
 689
 690 void ArgumentCoder<Cookie>::encode(ArgumentEncoder& encoder, const Cookie& cookie)
 691 {
 692     encoder << cookie.name;
 693     encoder << cookie.value;
 694     encoder << cookie.domain;
 695     encoder << cookie.path;
 696     encoder << cookie.expires;
 697     encoder << cookie.httpOnly;
 698     encoder << cookie.secure;
 699     encoder << cookie.session;
 700 }
 701
 702 bool ArgumentCoder<Cookie>::decode(ArgumentDecoder* decoder, Cookie& cookie)
 703 {
 704     if (!decoder->decode(cookie.name))
 705         return false;
 706     if (!decoder->decode(cookie.value))
 707         return false;
 708     if (!decoder->decode(cookie.domain))
 709         return false;
 710     if (!decoder->decode(cookie.path))
 711         return false;
 712     if (!decoder->decode(cookie.expires))
 713         return false;
 714     if (!decoder->decode(cookie.httpOnly))
 715         return false;
 716     if (!decoder->decode(cookie.secure))
 717         return false;
 718     if (!decoder->decode(cookie.session))
 719         return false;
 720
 721     return true;
 722 }
 723
 724
 725 #if ENABLE(SQL_DATABASE)
 726 void ArgumentCoder<DatabaseDetails>::encode(ArgumentEncoder& encoder, const DatabaseDetails& details)
 727 {
 728     encoder << details.name();
 729     encoder << details.displayName();
 730     encoder << details.expectedUsage();
 731     encoder << details.currentUsage();
 732 }
 733
 734 bool ArgumentCoder<DatabaseDetails>::decode(ArgumentDecoder* decoder, DatabaseDetails& details)
 735 {
 736     String name;
 737     if (!decoder->decode(name))
 738         return false;
 739
 740     String displayName;
 741     if (!decoder->decode(displayName))
 742         return false;
 743
 744     uint64_t expectedUsage;
 745     if (!decoder->decode(expectedUsage))
 746         return false;
 747
 748     uint64_t currentUsage;
 749     if (!decoder->decode(currentUsage))
 750         return false;
 751
 752     details = DatabaseDetails(name, displayName, expectedUsage, currentUsage);
 753     return true;
 754 }
 755 #endif
 756
 757 void ArgumentCoder<DictationAlternative>::encode(ArgumentEncoder& encoder, const DictationAlternative& dictationAlternative)
 758 {
 759     encoder << dictationAlternative.rangeStart;
 760     encoder << dictationAlternative.rangeLength;
 761     encoder << dictationAlternative.dictationContext;
 762 }
 763
 764 bool ArgumentCoder<DictationAlternative>::decode(ArgumentDecoder* decoder, DictationAlternative& dictationAlternative)
 765 {
 766     if (!decoder->decode(dictationAlternative.rangeStart))
 767         return false;
 768     if (!decoder->decode(dictationAlternative.rangeLength))
 769         return false;
 770     if (!decoder->decode(dictationAlternative.dictationContext))
 771         return false;
 772     return true;
 773 }
 774
 775
 776 void ArgumentCoder<FileChooserSettings>::encode(ArgumentEncoder& encoder, const FileChooserSettings& settings)
 777 {
 778     encoder << settings.allowsMultipleFiles;
 779 #if ENABLE(DIRECTORY_UPLOAD)
 780     encoder << settings.allowsDirectoryUpload;
 781 #endif
 782     encoder << settings.acceptMIMETypes;
 783     encoder << settings.selectedFiles;
 784 #if ENABLE(MEDIA_CAPTURE)
 785     encoder << settings.capture;
 786 #endif
 787 }
 788
 789 bool ArgumentCoder<FileChooserSettings>::decode(ArgumentDecoder* decoder, FileChooserSettings& settings)
 790 {
 791     if (!decoder->decode(settings.allowsMultipleFiles))
 792         return false;
 793 #if ENABLE(DIRECTORY_UPLOAD)
 794     if (!decoder->decode(settings.allowsDirectoryUpload))
 795         return false;
 796 #endif
 797     if (!decoder->decode(settings.acceptMIMETypes))
 798         return false;
 799     if (!decoder->decode(settings.selectedFiles))
 800         return false;
 801 #if ENABLE(MEDIA_CAPTURE)
 802     if (!decoder->decode(settings.capture))
 803         return false;
 804 #endif
 805
 806     return true;
 807 }
 808
 809
 810 void ArgumentCoder<GrammarDetail>::encode(ArgumentEncoder& encoder, const GrammarDetail& detail)
 811 {
 812     encoder << detail.location;
 813     encoder << detail.length;
 814     encoder << detail.guesses;
 815     encoder << detail.userDescription;
 816 }
 817
 818 bool ArgumentCoder<GrammarDetail>::decode(ArgumentDecoder* decoder, GrammarDetail& detail)
 819 {
 820     if (!decoder->decode(detail.location))
 821         return false;
 822     if (!decoder->decode(detail.length))
 823         return false;
 824     if (!decoder->decode(detail.guesses))
 825         return false;
 826     if (!decoder->decode(detail.userDescription))
 827         return false;
 828
 829     return true;
 830 }
 831
 832
 833 void ArgumentCoder<TextCheckingResult>::encode(ArgumentEncoder& encoder, const TextCheckingResult& result)
 834 {
 835     encoder.encodeEnum(result.type);
 836     encoder << result.location;
 837     encoder << result.length;
 838     encoder << result.details;
 839     encoder << result.replacement;
 840 }
 841
 842 bool ArgumentCoder<TextCheckingResult>::decode(ArgumentDecoder* decoder, TextCheckingResult& result)
 843 {
 844     if (!decoder->decodeEnum(result.type))
 845         return false;
 846     if (!decoder->decode(result.location))
 847         return false;
 848     if (!decoder->decode(result.length))
 849         return false;
 850     if (!decoder->decode(result.details))
 851         return false;
 852     if (!decoder->decode(result.replacement))
 853         return false;
 854     return true;
 855 }
 856
 857 void ArgumentCoder<DragSession>::encode(ArgumentEncoder& encoder, const DragSession& result)
 858 {
 859     encoder.encodeEnum(result.operation);
 860     encoder << result.mouseIsOverFileInput;
 861     encoder << result.numberOfItemsToBeAccepted;
 862 }
 863
 864 bool ArgumentCoder<DragSession>::decode(ArgumentDecoder* decoder, DragSession& result)
 865 {
 866     if (!decoder->decodeEnum(result.operation))
 867         return false;
 868     if (!decoder->decode(result.mouseIsOverFileInput))
 869         return false;
 870     if (!decoder->decode(result.numberOfItemsToBeAccepted))
 871         return false;
 872     return true;
 873 }
 874
 875 void ArgumentCoder<KURL>::encode(ArgumentEncoder& encoder, const KURL& result)
 876 {
 877     encoder << result.string();
 878 }
 879
 880 bool ArgumentCoder<KURL>::decode(ArgumentDecoder* decoder, KURL& result)
 881 {
 882     String urlAsString;
 883     if (!decoder->decode(urlAsString))
 884         return false;
 885     result = KURL(WebCore::ParsedURLString, urlAsString);
 886     return true;
 887 }
 888
 889 void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder& encoder, const WebCore::UserStyleSheet& userStyleSheet)
 890 {
 891     encoder << userStyleSheet.source();
 892     encoder << userStyleSheet.url();
 893     encoder << userStyleSheet.whitelist();
 894     encoder << userStyleSheet.blacklist();
 895     encoder.encodeEnum(userStyleSheet.injectedFrames());
 896     encoder.encodeEnum(userStyleSheet.level());
 897 }
 898
 899 bool ArgumentCoder<WebCore::UserStyleSheet>::decode(ArgumentDecoder* decoder, WebCore::UserStyleSheet& userStyleSheet)
 900 {
 901     String source;
 902     if (!decoder->decode(source))
 903         return false;
 904
 905     KURL url;
 906     if (!decoder->decode(url))
 907         return false;
 908
 909     Vector<String> whitelist;
 910     if (!decoder->decode(whitelist))
 911         return false;
 912
 913     Vector<String> blacklist;
 914     if (!decoder->decode(blacklist))
 915         return false;
 916
 917     WebCore::UserContentInjectedFrames injectedFrames;
 918     if (!decoder->decodeEnum(injectedFrames))
 919         return false;
 920
 921     WebCore::UserStyleLevel level;
 922     if (!decoder->decodeEnum(level))
 923         return false;
 924
 925     userStyleSheet = WebCore::UserStyleSheet(source, url, whitelist, blacklist, injectedFrames, level);
 926     return true;
 927 }
 928
 929 void ArgumentCoder<WebCore::UserScript>::encode(ArgumentEncoder& encoder, const WebCore::UserScript& userScript)
 930 {
 931     encoder << userScript.source();
 932     encoder << userScript.url();
 933     encoder << userScript.whitelist();
 934     encoder << userScript.blacklist();
 935     encoder.encodeEnum(userScript.injectionTime());
 936     encoder.encodeEnum(userScript.injectedFrames());
 937 }
 938
 939 bool ArgumentCoder<WebCore::UserScript>::decode(ArgumentDecoder* decoder, WebCore::UserScript& userScript)
 940 {
 941     String source;
 942     if (!decoder->decode(source))
 943         return false;
 944
 945     KURL url;
 946     if (!decoder->decode(url))
 947         return false;
 948
 949     Vector<String> whitelist;
 950     if (!decoder->decode(whitelist))
 951         return false;
 952
 953     Vector<String> blacklist;
 954     if (!decoder->decode(blacklist))
 955         return false;
 956
 957     WebCore::UserScriptInjectionTime injectionTime;
 958     if (!decoder->decodeEnum(injectionTime))
 959         return false;
 960
 961     WebCore::UserContentInjectedFrames injectedFrames;
 962     if (!decoder->decodeEnum(injectedFrames))
 963         return false;
 964
 965     userScript = WebCore::UserScript(source, url, whitelist, blacklist, injectionTime, injectedFrames);
 966     return true;
 967 }
 968
 969 } // namespace CoreIPC