1 /* 2 * Copyright (C) 2010, 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 #ifndef WebCoreArgumentCoders_h 27 #define WebCoreArgumentCoders_h 28 29 #include "ArgumentCoders.h" 30 #include "ArgumentDecoder.h" 31 #include "ArgumentEncoder.h" 32 #include "Arguments.h" 33 #include "ShareableBitmap.h" 34 #include <WebCore/AuthenticationChallenge.h> 35 #include <WebCore/BitmapImage.h> 36 #include <WebCore/Credential.h> 37 #include <WebCore/Cursor.h> 38 #include <WebCore/DatabaseDetails.h> 39 #include <WebCore/Editor.h> 40 #include <WebCore/EditorClient.h> 41 #include <WebCore/FloatRect.h> 42 #include <WebCore/GraphicsContext.h> 43 #include <WebCore/IntRect.h> 44 #include <WebCore/KeyboardEvent.h> 45 #include <WebCore/PluginData.h> 46 #include <WebCore/ProtectionSpace.h> 47 #include <WebCore/ResourceError.h> 48 #include <WebCore/ResourceRequest.h> 49 #include <WebCore/TextCheckerClient.h> 50 #include <WebCore/ViewportArguments.h> 51 #include <WebCore/WindowFeatures.h> 52 #include <limits> 53 54 namespace CoreIPC { 55 56 template<> struct ArgumentCoder<WebCore::IntPoint> : SimpleArgumentCoder<WebCore::IntPoint> { }; 57 template<> struct ArgumentCoder<WebCore::IntSize> : SimpleArgumentCoder<WebCore::IntSize> { }; 58 template<> struct ArgumentCoder<WebCore::IntRect> : SimpleArgumentCoder<WebCore::IntRect> { }; 59 template<> struct ArgumentCoder<WebCore::ViewportArguments> : SimpleArgumentCoder<WebCore::ViewportArguments> { }; 60 61 template<> struct ArgumentCoder<WebCore::FloatPoint> : SimpleArgumentCoder<WebCore::FloatPoint> { }; 62 template<> struct ArgumentCoder<WebCore::FloatSize> : SimpleArgumentCoder<WebCore::FloatSize> { }; 63 template<> struct ArgumentCoder<WebCore::FloatRect> : SimpleArgumentCoder<WebCore::FloatRect> { }; 64 65 template<> struct ArgumentCoder<WebCore::MimeClassInfo> { 66 static void encode(ArgumentEncoder* encoder, const WebCore::MimeClassInfo& mimeClassInfo) 67 { 68 encoder->encode(mimeClassInfo.type); 69 encoder->encode(mimeClassInfo.desc); 70 encoder->encode(mimeClassInfo.extensions); 71 } 72 73 static bool decode(ArgumentDecoder* decoder, WebCore::MimeClassInfo& mimeClassInfo) 74 { 75 if (!decoder->decode(mimeClassInfo.type)) 76 return false; 77 if (!decoder->decode(mimeClassInfo.desc)) 78 return false; 79 if (!decoder->decode(mimeClassInfo.extensions)) 80 return false; 81 82 return true; 83 } 84 }; 85 86 template<> struct ArgumentCoder<WebCore::PluginInfo> { 87 static void encode(ArgumentEncoder* encoder, const WebCore::PluginInfo& pluginInfo) 88 { 89 encoder->encode(pluginInfo.name); 90 encoder->encode(pluginInfo.file); 91 encoder->encode(pluginInfo.desc); 92 encoder->encode(pluginInfo.mimes); 93 } 94 95 static bool decode(ArgumentDecoder* decoder, WebCore::PluginInfo& pluginInfo) 96 { 97 if (!decoder->decode(pluginInfo.name)) 98 return false; 99 if (!decoder->decode(pluginInfo.file)) 100 return false; 101 if (!decoder->decode(pluginInfo.desc)) 102 return false; 103 if (!decoder->decode(pluginInfo.mimes)) 104 return false; 105 106 return true; 107 } 108 }; 109 110 template<> struct ArgumentCoder<WebCore::HTTPHeaderMap> { 111 static void encode(ArgumentEncoder* encoder, const WebCore::HTTPHeaderMap& headerMap) 112 { 113 encoder->encode(static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap)); 114 } 115 116 static bool decode(ArgumentDecoder* decoder, WebCore::HTTPHeaderMap& headerMap) 117 { 118 return decoder->decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap)); 119 } 120 }; 121 122 template<> struct ArgumentCoder<WebCore::AuthenticationChallenge> { 123 static void encode(ArgumentEncoder* encoder, const WebCore::AuthenticationChallenge& challenge) 124 { 125 encoder->encode(CoreIPC::In(challenge.protectionSpace(), challenge.proposedCredential(), challenge.previousFailureCount(), challenge.failureResponse(), challenge.error())); 126 } 127 128 static bool decode(ArgumentDecoder* decoder, WebCore::AuthenticationChallenge& challenge) 129 { 130 WebCore::ProtectionSpace protectionSpace; 131 WebCore::Credential proposedCredential; 132 unsigned previousFailureCount; 133 WebCore::ResourceResponse failureResponse; 134 WebCore::ResourceError error; 135 136 if (!decoder->decode(CoreIPC::Out(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error))) 137 return false; 138 139 challenge = WebCore::AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error); 140 141 return true; 142 } 143 }; 144 145 template<> struct ArgumentCoder<WebCore::ProtectionSpace> { 146 static void encode(ArgumentEncoder* encoder, const WebCore::ProtectionSpace& space) 147 { 148 encoder->encode(CoreIPC::In(space.host(), space.port(), static_cast<uint32_t>(space.serverType()), space.realm(), static_cast<uint32_t>(space.authenticationScheme()))); 149 } 150 151 static bool decode(ArgumentDecoder* decoder, WebCore::ProtectionSpace& space) 152 { 153 String host; 154 int port; 155 uint32_t serverType; 156 String realm; 157 uint32_t authenticationScheme; 158 159 if (!decoder->decode(CoreIPC::Out(host, port, serverType, realm, authenticationScheme))) 160 return false; 161 162 space = WebCore::ProtectionSpace(host, port, static_cast<WebCore::ProtectionSpaceServerType>(serverType), realm, static_cast<WebCore::ProtectionSpaceAuthenticationScheme>(authenticationScheme)); 163 164 return true; 165 } 166 }; 167 168 template<> struct ArgumentCoder<WebCore::Credential> { 169 static void encode(ArgumentEncoder* encoder, const WebCore::Credential& credential) 170 { 171 encoder->encode(CoreIPC::In(credential.user(), credential.password(), static_cast<uint32_t>(credential.persistence()))); 172 } 173 174 static bool decode(ArgumentDecoder* decoder, WebCore::Credential& credential) 175 { 176 String user; 177 String password; 178 int persistence; 179 if (!decoder->decode(CoreIPC::Out(user, password, persistence))) 180 return false; 181 182 credential = WebCore::Credential(user, password, static_cast<WebCore::CredentialPersistence>(persistence)); 183 return true; 184 } 185 }; 186 187 #if USE(LAZY_NATIVE_CURSOR) 188 189 void encodeImage(ArgumentEncoder*, WebCore::Image*); 190 bool decodeImage(ArgumentDecoder*, RefPtr<WebCore::Image>&); 191 RefPtr<WebCore::Image> createImage(WebKit::ShareableBitmap*); 192 193 template<> struct ArgumentCoder<WebCore::Cursor> { 194 static void encode(ArgumentEncoder* encoder, const WebCore::Cursor& cursor) 195 { 196 WebCore::Cursor::Type type = cursor.type(); 197 #if !USE(CG) 198 // FIXME: Currently we only have the createImage function implemented for CG. 199 // Once we implement it for other platforms we can remove this conditional, 200 // and the other conditionals below and in WebCoreArgumentCoders.cpp. 201 if (type == WebCore::Cursor::Custom) 202 type = WebCore::Cursor::Pointer; 203 #endif 204 encoder->encode(static_cast<uint32_t>(type)); 205 #if USE(CG) 206 if (type != WebCore::Cursor::Custom) 207 return; 208 209 encodeImage(encoder, cursor.image()); 210 encoder->encode(cursor.hotSpot()); 211 #endif 212 } 213 214 static bool decode(ArgumentDecoder* decoder, WebCore::Cursor& cursor) 215 { 216 uint32_t typeInt; 217 if (!decoder->decode(typeInt)) 218 return false; 219 if (typeInt > WebCore::Cursor::Custom) 220 return false; 221 WebCore::Cursor::Type type = static_cast<WebCore::Cursor::Type>(typeInt); 222 223 if (type != WebCore::Cursor::Custom) { 224 cursor = WebCore::Cursor::fromType(type); 225 return true; 226 } 227 228 #if !USE(CG) 229 return false; 230 #else 231 RefPtr<WebCore::Image> image; 232 if (!decodeImage(decoder, image)) 233 return false; 234 WebCore::IntPoint hotSpot; 235 if (!decoder->decode(hotSpot)) 236 return false; 237 if (!image->rect().contains(WebCore::IntRect(hotSpot, WebCore::IntSize()))) 238 return false; 239 240 cursor = WebCore::Cursor(image.get(), hotSpot); 241 return true; 242 #endif 243 } 244 }; 245 246 #endif 247 248 // These two functions are implemented in a platform specific manner. 249 void encodeResourceRequest(ArgumentEncoder*, const WebCore::ResourceRequest&); 250 bool decodeResourceRequest(ArgumentDecoder*, WebCore::ResourceRequest&); 251 252 template<> struct ArgumentCoder<WebCore::ResourceRequest> { 253 static void encode(ArgumentEncoder* encoder, const WebCore::ResourceRequest& resourceRequest) 254 { 255 encodeResourceRequest(encoder, resourceRequest); 256 } 257 258 static bool decode(ArgumentDecoder* decoder, WebCore::ResourceRequest& resourceRequest) 259 { 260 return decodeResourceRequest(decoder, resourceRequest); 261 } 262 }; 263 264 // These two functions are implemented in a platform specific manner. 265 void encodeResourceResponse(ArgumentEncoder*, const WebCore::ResourceResponse&); 266 bool decodeResourceResponse(ArgumentDecoder*, WebCore::ResourceResponse&); 267 268 template<> struct ArgumentCoder<WebCore::ResourceResponse> { 269 static void encode(ArgumentEncoder* encoder, const WebCore::ResourceResponse& resourceResponse) 270 { 271 encodeResourceResponse(encoder, resourceResponse); 272 } 273 274 static bool decode(ArgumentDecoder* decoder, WebCore::ResourceResponse& resourceResponse) 275 { 276 return decodeResourceResponse(decoder, resourceResponse); 277 } 278 }; 279 280 // These two functions are implemented in a platform specific manner. 281 void encodeResourceError(ArgumentEncoder*, const WebCore::ResourceError&); 282 bool decodeResourceError(ArgumentDecoder*, WebCore::ResourceError&); 283 284 template<> struct ArgumentCoder<WebCore::ResourceError> { 285 static void encode(ArgumentEncoder* encoder, const WebCore::ResourceError& resourceError) 286 { 287 encodeResourceError(encoder, resourceError); 288 } 289 290 static bool decode(ArgumentDecoder* decoder, WebCore::ResourceError& resourceError) 291 { 292 return decodeResourceError(decoder, resourceError); 293 } 294 }; 295 296 template<> struct ArgumentCoder<WebCore::WindowFeatures> { 297 static void encode(ArgumentEncoder* encoder, const WebCore::WindowFeatures& windowFeatures) 298 { 299 encoder->encode(windowFeatures.x); 300 encoder->encode(windowFeatures.y); 301 encoder->encode(windowFeatures.width); 302 encoder->encode(windowFeatures.height); 303 encoder->encode(windowFeatures.xSet); 304 encoder->encode(windowFeatures.ySet); 305 encoder->encode(windowFeatures.widthSet); 306 encoder->encode(windowFeatures.heightSet); 307 encoder->encode(windowFeatures.menuBarVisible); 308 encoder->encode(windowFeatures.statusBarVisible); 309 encoder->encode(windowFeatures.toolBarVisible); 310 encoder->encode(windowFeatures.locationBarVisible); 311 encoder->encode(windowFeatures.scrollbarsVisible); 312 encoder->encode(windowFeatures.resizable); 313 encoder->encode(windowFeatures.fullscreen); 314 encoder->encode(windowFeatures.dialog); 315 } 316 317 static bool decode(ArgumentDecoder* decoder, WebCore::WindowFeatures& windowFeatures) 318 { 319 if (!decoder->decode(windowFeatures.x)) 320 return false; 321 if (!decoder->decode(windowFeatures.y)) 322 return false; 323 if (!decoder->decode(windowFeatures.width)) 324 return false; 325 if (!decoder->decode(windowFeatures.height)) 326 return false; 327 if (!decoder->decode(windowFeatures.xSet)) 328 return false; 329 if (!decoder->decode(windowFeatures.ySet)) 330 return false; 331 if (!decoder->decode(windowFeatures.widthSet)) 332 return false; 333 if (!decoder->decode(windowFeatures.heightSet)) 334 return false; 335 if (!decoder->decode(windowFeatures.menuBarVisible)) 336 return false; 337 if (!decoder->decode(windowFeatures.statusBarVisible)) 338 return false; 339 if (!decoder->decode(windowFeatures.toolBarVisible)) 340 return false; 341 if (!decoder->decode(windowFeatures.locationBarVisible)) 342 return false; 343 if (!decoder->decode(windowFeatures.scrollbarsVisible)) 344 return false; 345 if (!decoder->decode(windowFeatures.resizable)) 346 return false; 347 if (!decoder->decode(windowFeatures.fullscreen)) 348 return false; 349 if (!decoder->decode(windowFeatures.dialog)) 350 return false; 351 return true; 352 } 353 }; 354 355 template<> struct ArgumentCoder<WebCore::Color> { 356 static void encode(ArgumentEncoder* encoder, const WebCore::Color& color) 357 { 358 if (!color.isValid()) { 359 encoder->encodeBool(false); 360 return; 361 } 362 363 encoder->encodeBool(true); 364 encoder->encode(color.rgb()); 365 } 366 367 static bool decode(ArgumentDecoder* decoder, WebCore::Color& color) 368 { 369 bool isValid; 370 if (!decoder->decode(isValid)) 371 return false; 372 373 if (!isValid) { 374 color = WebCore::Color(); 375 return true; 376 } 377 378 WebCore::RGBA32 rgba; 379 if (!decoder->decode(rgba)) 380 return false; 381 382 color = WebCore::Color(rgba); 383 return true; 384 } 385 }; 386 387 #if PLATFORM(MAC) 388 template<> struct ArgumentCoder<WebCore::KeypressCommand> { 389 static void encode(ArgumentEncoder* encoder, const WebCore::KeypressCommand& keypressCommand) 390 { 391 encoder->encode(CoreIPC::In(keypressCommand.commandName, keypressCommand.text)); 392 } 393 394 static bool decode(ArgumentDecoder* decoder, WebCore::KeypressCommand& keypressCommand) 395 { 396 return decoder->decode(CoreIPC::Out(keypressCommand.commandName, keypressCommand.text)); 397 } 398 }; 399 #endif 400 401 template<> struct ArgumentCoder<WebCore::CompositionUnderline> { 402 static void encode(ArgumentEncoder* encoder, const WebCore::CompositionUnderline& underline) 403 { 404 encoder->encode(CoreIPC::In(underline.startOffset, underline.endOffset, underline.thick, underline.color)); 405 } 406 407 static bool decode(ArgumentDecoder* decoder, WebCore::CompositionUnderline& underline) 408 { 409 return decoder->decode(CoreIPC::Out(underline.startOffset, underline.endOffset, underline.thick, underline.color)); 410 } 411 }; 412 413 template<> struct ArgumentCoder<WebCore::DatabaseDetails> { 414 static void encode(ArgumentEncoder* encoder, const WebCore::DatabaseDetails& details) 415 { 416 encoder->encode(CoreIPC::In(details.name(), details.displayName(), details.expectedUsage(), details.currentUsage())); 417 } 418 419 static bool decode(ArgumentDecoder* decoder, WebCore::DatabaseDetails& details) 420 { 421 String name; 422 String displayName; 423 uint64_t expectedUsage; 424 uint64_t currentUsage; 425 if (!decoder->decode(CoreIPC::Out(name, displayName, expectedUsage, currentUsage))) 426 return false; 427 428 details = WebCore::DatabaseDetails(name, displayName, expectedUsage, currentUsage); 429 return true; 430 } 431 }; 432 433 template<> struct ArgumentCoder<WebCore::GrammarDetail> { 434 static void encode(ArgumentEncoder* encoder, const WebCore::GrammarDetail& detail) 435 { 436 encoder->encodeInt32(detail.location); 437 encoder->encodeInt32(detail.length); 438 encoder->encode(detail.guesses); 439 encoder->encode(detail.userDescription); 440 } 441 442 static bool decode(ArgumentDecoder* decoder, WebCore::GrammarDetail& detail) 443 { 444 if (!decoder->decodeInt32(detail.location)) 445 return false; 446 if (!decoder->decodeInt32(detail.length)) 447 return false; 448 if (!decoder->decode(detail.guesses)) 449 return false; 450 if (!decoder->decode(detail.userDescription)) 451 return false; 452 453 return true; 454 } 455 }; 456 457 template<> struct ArgumentCoder<WebCore::TextCheckingResult> { 458 static void encode(ArgumentEncoder* encoder, const WebCore::TextCheckingResult& result) 459 { 460 encoder->encodeEnum(result.type); 461 encoder->encodeInt32(result.location); 462 encoder->encodeInt32(result.length); 463 encoder->encode(result.details); 464 encoder->encode(result.replacement); 465 } 466 467 static bool decode(ArgumentDecoder* decoder, WebCore::TextCheckingResult& result) 468 { 469 if (!decoder->decodeEnum(result.type)) 470 return false; 471 if (!decoder->decodeInt32(result.location)) 472 return false; 473 if (!decoder->decodeInt32(result.length)) 474 return false; 475 if (!decoder->decode(result.details)) 476 return false; 477 if (!decoder->decode(result.replacement)) 478 return false; 479 return true; 480 } 481 }; 482 483 } // namespace CoreIPC 484 485 #endif // WebCoreArgumentCoders_h 486
