LayersMessageUtils.h (49308B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #ifndef mozilla_layers_LayersMessageUtils 8 #define mozilla_layers_LayersMessageUtils 9 10 #include <stdint.h> 11 12 #include <utility> 13 14 #include "FrameMetrics.h" 15 #include "VsyncSource.h" 16 #include "chrome/common/ipc_message_utils.h" 17 #include "ImageContainer.h" 18 #include "ipc/EnumSerializer.h" 19 #include "ipc/IPCMessageUtils.h" 20 #include "mozilla/RelativeTo.h" 21 #include "mozilla/ScrollSnapInfo.h" 22 #include "mozilla/ServoBindings.h" 23 #include "mozilla/ParamTraits_IsEnumCase.h" 24 #include "mozilla/ParamTraits_TiedFields.h" 25 #include "mozilla/ipc/ByteBuf.h" 26 #include "mozilla/ipc/ProtocolMessageUtils.h" 27 #include "mozilla/ipc/RustMessageUtils.h" 28 #include "mozilla/layers/APZInputBridge.h" 29 #include "mozilla/layers/AsyncDragMetrics.h" 30 #include "mozilla/layers/CompositorOptions.h" 31 #include "mozilla/layers/CompositorScrollUpdate.h" 32 #include "mozilla/layers/CompositorTypes.h" 33 #include "mozilla/layers/FocusTarget.h" 34 #include "mozilla/layers/GeckoContentControllerTypes.h" 35 #include "mozilla/layers/GpuFence.h" 36 #include "mozilla/layers/KeyboardMap.h" 37 #include "mozilla/layers/LayersTypes.h" 38 #include "mozilla/layers/MatrixMessage.h" 39 #include "mozilla/layers/OverlayInfo.h" 40 #include "mozilla/layers/RepaintRequest.h" 41 #include "mozilla/layers/ScrollbarData.h" 42 #include "nsSize.h" 43 #include "mozilla/layers/DoubleTapToZoom.h" 44 45 // For ParamTraits, could be moved to cpp file 46 #include "ipc/nsGUIEventIPC.h" 47 #include "mozilla/GfxMessageUtils.h" 48 #include "mozilla/ipc/ByteBufUtils.h" 49 50 #ifdef _MSC_VER 51 # pragma warning(disable : 4800) 52 #endif 53 54 namespace IPC { 55 56 template <> 57 struct ParamTraits<mozilla::layers::LayersId> 58 : public ParamTraits_TiedFields<mozilla::layers::LayersId> {}; 59 60 template <typename T> 61 struct ParamTraits<mozilla::layers::BaseTransactionId<T>> 62 : public ParamTraits_TiedFields<mozilla::layers::BaseTransactionId<T>> {}; 63 64 template <> 65 struct ParamTraits<mozilla::VsyncEvent> { 66 typedef mozilla::VsyncEvent paramType; 67 68 static void Write(MessageWriter* writer, const paramType& param) { 69 WriteParam(writer, param.mId); 70 WriteParam(writer, param.mTime); 71 WriteParam(writer, param.mOutputTime); 72 } 73 static bool Read(MessageReader* reader, paramType* result) { 74 return ReadParam(reader, &result->mId) && 75 ReadParam(reader, &result->mTime) && 76 ReadParam(reader, &result->mOutputTime); 77 } 78 }; 79 80 template <> 81 struct ParamTraits<mozilla::layers::MatrixMessage> { 82 typedef mozilla::layers::MatrixMessage paramType; 83 84 static void Write(MessageWriter* aWriter, const paramType& aParam) { 85 WriteParam(aWriter, aParam.mMatrix); 86 WriteParam(aWriter, aParam.mTopLevelViewportVisibleRectInBrowserCoords); 87 WriteParam(aWriter, aParam.mLayersId); 88 } 89 static bool Read(MessageReader* aReader, paramType* aResult) { 90 return ReadParam(aReader, &aResult->mMatrix) && 91 ReadParam(aReader, 92 &aResult->mTopLevelViewportVisibleRectInBrowserCoords) && 93 ReadParam(aReader, &aResult->mLayersId); 94 } 95 }; 96 97 template <> 98 struct ParamTraits<mozilla::layers::WindowKind> 99 : public ContiguousEnumSerializer<mozilla::layers::WindowKind, 100 mozilla::layers::WindowKind::MAIN, 101 mozilla::layers::WindowKind::LAST> {}; 102 103 template <> 104 struct ParamTraits<mozilla::layers::LayersBackend> 105 : public ContiguousEnumSerializer< 106 mozilla::layers::LayersBackend, 107 mozilla::layers::LayersBackend::LAYERS_NONE, 108 mozilla::layers::LayersBackend::LAYERS_LAST> {}; 109 110 template <> 111 struct ParamTraits<mozilla::layers::WebRenderBackend> 112 : public ContiguousEnumSerializer< 113 mozilla::layers::WebRenderBackend, 114 mozilla::layers::WebRenderBackend::HARDWARE, 115 mozilla::layers::WebRenderBackend::LAST> {}; 116 117 template <> 118 struct ParamTraits<mozilla::layers::WebRenderCompositor> 119 : public ContiguousEnumSerializer< 120 mozilla::layers::WebRenderCompositor, 121 mozilla::layers::WebRenderCompositor::DRAW, 122 mozilla::layers::WebRenderCompositor::LAST> {}; 123 124 template <> 125 struct ParamTraits<mozilla::layers::TextureType> 126 : public ContiguousEnumSerializer<mozilla::layers::TextureType, 127 mozilla::layers::TextureType::Unknown, 128 mozilla::layers::TextureType::Last> {}; 129 130 template <> 131 struct ParamTraits<mozilla::layers::ScaleMode> 132 : public ContiguousEnumSerializerInclusive< 133 mozilla::layers::ScaleMode, mozilla::layers::ScaleMode::SCALE_NONE, 134 mozilla::layers::kHighestScaleMode> {}; 135 136 template <> 137 struct ParamTraits<mozilla::StyleScrollSnapStrictness> 138 : public ContiguousEnumSerializerInclusive< 139 mozilla::StyleScrollSnapStrictness, 140 mozilla::StyleScrollSnapStrictness::None, 141 mozilla::StyleScrollSnapStrictness::Proximity> {}; 142 143 template <> 144 struct ParamTraits<mozilla::layers::TextureFlags> 145 : public BitFlagsEnumSerializer<mozilla::layers::TextureFlags, 146 mozilla::layers::TextureFlags::ALL_BITS> {}; 147 148 template <> 149 struct ParamTraits<mozilla::layers::DiagnosticTypes> 150 : public BitFlagsEnumSerializer< 151 mozilla::layers::DiagnosticTypes, 152 mozilla::layers::DiagnosticTypes::ALL_BITS> {}; 153 154 template <> 155 struct ParamTraits<mozilla::layers::ScrollDirection> 156 : public ContiguousEnumSerializerInclusive< 157 mozilla::layers::ScrollDirection, 158 mozilla::layers::ScrollDirection::eVertical, 159 mozilla::layers::kHighestScrollDirection> {}; 160 161 template <> 162 struct ParamTraits<mozilla::layers::FrameMetrics::ScrollOffsetUpdateType> 163 : public ContiguousEnumSerializerInclusive< 164 mozilla::layers::FrameMetrics::ScrollOffsetUpdateType, 165 mozilla::layers::FrameMetrics::ScrollOffsetUpdateType::eNone, 166 mozilla::layers::FrameMetrics::sHighestScrollOffsetUpdateType> {}; 167 168 template <> 169 struct ParamTraits<mozilla::layers::RepaintRequest::ScrollOffsetUpdateType> 170 : public ContiguousEnumSerializerInclusive< 171 mozilla::layers::RepaintRequest::ScrollOffsetUpdateType, 172 mozilla::layers::RepaintRequest::ScrollOffsetUpdateType::eNone, 173 mozilla::layers::RepaintRequest::sHighestScrollOffsetUpdateType> {}; 174 175 template <> 176 struct ParamTraits<mozilla::layers::OverscrollBehavior> 177 : public ContiguousEnumSerializerInclusive< 178 mozilla::layers::OverscrollBehavior, 179 mozilla::layers::OverscrollBehavior::Auto, 180 mozilla::layers::kHighestOverscrollBehavior> {}; 181 182 template <> 183 struct ParamTraits<mozilla::StyleOverflow> 184 : public ContiguousEnumSerializerInclusive<mozilla::StyleOverflow, 185 mozilla::StyleOverflow::Visible, 186 mozilla::StyleOverflow::Clip> {}; 187 188 template <> 189 struct ParamTraits<mozilla::layers::LayerHandle> { 190 typedef mozilla::layers::LayerHandle paramType; 191 192 static void Write(MessageWriter* writer, const paramType& param) { 193 WriteParam(writer, param.mHandle); 194 } 195 static bool Read(MessageReader* reader, paramType* result) { 196 return ReadParam(reader, &result->mHandle); 197 } 198 }; 199 200 template <> 201 struct ParamTraits<mozilla::layers::CompositableHandle> { 202 typedef mozilla::layers::CompositableHandle paramType; 203 204 static void Write(MessageWriter* writer, const paramType& param) { 205 WriteParam(writer, param.mHandle); 206 } 207 static bool Read(MessageReader* reader, paramType* result) { 208 return ReadParam(reader, &result->mHandle); 209 } 210 }; 211 212 template <> 213 struct ParamTraits<mozilla::layers::CompositableHandleOwner> 214 : public ContiguousEnumSerializerInclusive< 215 mozilla::layers::CompositableHandleOwner, 216 mozilla::layers::CompositableHandleOwner::WebRenderBridge, 217 mozilla::layers::CompositableHandleOwner::ImageBridge> {}; 218 219 template <> 220 struct ParamTraits<mozilla::layers::RemoteTextureId> { 221 typedef mozilla::layers::RemoteTextureId paramType; 222 223 static void Write(MessageWriter* writer, const paramType& param) { 224 WriteParam(writer, param.mId); 225 } 226 static bool Read(MessageReader* reader, paramType* result) { 227 return ReadParam(reader, &result->mId); 228 } 229 }; 230 231 template <> 232 struct ParamTraits<mozilla::layers::RemoteTextureOwnerId> { 233 typedef mozilla::layers::RemoteTextureOwnerId paramType; 234 235 static void Write(MessageWriter* writer, const paramType& param) { 236 WriteParam(writer, param.mId); 237 } 238 static bool Read(MessageReader* reader, paramType* result) { 239 return ReadParam(reader, &result->mId); 240 } 241 }; 242 243 template <> 244 struct ParamTraits<mozilla::layers::SurfaceDescriptorRemoteDecoderId> { 245 typedef mozilla::layers::SurfaceDescriptorRemoteDecoderId paramType; 246 247 static void Write(MessageWriter* writer, const paramType& param) { 248 WriteParam(writer, param.mId); 249 } 250 static bool Read(MessageReader* reader, paramType* result) { 251 return ReadParam(reader, &result->mId); 252 } 253 }; 254 255 template <> 256 struct ParamTraits<mozilla::layers::GpuProcessTextureId> { 257 typedef mozilla::layers::GpuProcessTextureId paramType; 258 259 static void Write(MessageWriter* writer, const paramType& param) { 260 WriteParam(writer, param.mId); 261 } 262 static bool Read(MessageReader* reader, paramType* result) { 263 return ReadParam(reader, &result->mId); 264 } 265 }; 266 267 template <> 268 struct ParamTraits<mozilla::layers::CompositeProcessFencesHolderId> { 269 typedef mozilla::layers::CompositeProcessFencesHolderId paramType; 270 271 static void Write(MessageWriter* writer, const paramType& param) { 272 WriteParam(writer, param.mId); 273 } 274 static bool Read(MessageReader* reader, paramType* result) { 275 return ReadParam(reader, &result->mId); 276 } 277 }; 278 279 template <> 280 struct ParamTraits<mozilla::layers::FrameMetrics> 281 : BitfieldHelper<mozilla::layers::FrameMetrics> { 282 typedef mozilla::layers::FrameMetrics paramType; 283 284 static void Write(MessageWriter* aWriter, const paramType& aParam) { 285 WriteParam(aWriter, aParam.mScrollId); 286 WriteParam(aWriter, aParam.mPresShellResolution); 287 WriteParam(aWriter, aParam.mCompositionBounds); 288 WriteParam(aWriter, aParam.mCompositionBoundsWidthIgnoringScrollbars); 289 WriteParam(aWriter, aParam.mDisplayPort); 290 WriteParam(aWriter, aParam.mScrollableRect); 291 WriteParam(aWriter, aParam.mCumulativeResolution); 292 WriteParam(aWriter, aParam.mDevPixelsPerCSSPixel); 293 WriteParam(aWriter, aParam.mScrollOffset); 294 WriteParam(aWriter, aParam.mZoom); 295 WriteParam(aWriter, aParam.mScrollGeneration); 296 WriteParam(aWriter, aParam.mBoundingCompositionSize); 297 WriteParam(aWriter, aParam.mPresShellId); 298 WriteParam(aWriter, aParam.mLayoutViewport); 299 WriteParam(aWriter, aParam.mTransformToAncestorScale); 300 WriteParam(aWriter, aParam.mPaintRequestTime); 301 WriteParam(aWriter, aParam.mVisualDestination); 302 WriteParam(aWriter, aParam.mVisualScrollUpdateType); 303 WriteParam(aWriter, aParam.mFixedLayerMargins); 304 WriteParam(aWriter, aParam.mCompositionSizeWithoutDynamicToolbar); 305 WriteParam(aWriter, aParam.mInteractiveWidget); 306 WriteParam(aWriter, aParam.mIsRootContent); 307 WriteParam(aWriter, aParam.mIsScrollInfoLayer); 308 WriteParam(aWriter, aParam.mHasNonZeroDisplayPortMargins); 309 WriteParam(aWriter, aParam.mMinimalDisplayPort); 310 WriteParam(aWriter, aParam.mIsSoftwareKeyboardVisible); 311 } 312 313 static bool Read(MessageReader* aReader, paramType* aResult) { 314 return ( 315 ReadParam(aReader, &aResult->mScrollId) && 316 ReadParam(aReader, &aResult->mPresShellResolution) && 317 ReadParam(aReader, &aResult->mCompositionBounds) && 318 ReadParam(aReader, 319 &aResult->mCompositionBoundsWidthIgnoringScrollbars) && 320 ReadParam(aReader, &aResult->mDisplayPort) && 321 ReadParam(aReader, &aResult->mScrollableRect) && 322 ReadParam(aReader, &aResult->mCumulativeResolution) && 323 ReadParam(aReader, &aResult->mDevPixelsPerCSSPixel) && 324 ReadParam(aReader, &aResult->mScrollOffset) && 325 ReadParam(aReader, &aResult->mZoom) && 326 ReadParam(aReader, &aResult->mScrollGeneration) && 327 ReadParam(aReader, &aResult->mBoundingCompositionSize) && 328 ReadParam(aReader, &aResult->mPresShellId) && 329 ReadParam(aReader, &aResult->mLayoutViewport) && 330 ReadParam(aReader, &aResult->mTransformToAncestorScale) && 331 ReadParam(aReader, &aResult->mPaintRequestTime) && 332 ReadParam(aReader, &aResult->mVisualDestination) && 333 ReadParam(aReader, &aResult->mVisualScrollUpdateType) && 334 ReadParam(aReader, &aResult->mFixedLayerMargins) && 335 ReadParam(aReader, &aResult->mCompositionSizeWithoutDynamicToolbar) && 336 ReadParam(aReader, &aResult->mInteractiveWidget) && 337 ReadBoolForBitfield(aReader, aResult, ¶mType::SetIsRootContent) && 338 ReadBoolForBitfield(aReader, aResult, 339 ¶mType::SetIsScrollInfoLayer) && 340 ReadBoolForBitfield(aReader, aResult, 341 ¶mType::SetHasNonZeroDisplayPortMargins) && 342 ReadBoolForBitfield(aReader, aResult, 343 ¶mType::SetMinimalDisplayPort) && 344 ReadBoolForBitfield(aReader, aResult, 345 ¶mType::SetIsSoftwareKeyboardVisible)); 346 } 347 }; 348 349 template <> 350 struct ParamTraits<mozilla::APZScrollAnimationType> 351 : public ContiguousEnumSerializerInclusive< 352 mozilla::APZScrollAnimationType, mozilla::APZScrollAnimationType::No, 353 mozilla::APZScrollAnimationType::TriggeredByUserInput> {}; 354 355 template <> 356 struct ParamTraits<mozilla::ScrollSnapTargetIds> { 357 typedef mozilla::ScrollSnapTargetIds paramType; 358 359 static void Write(MessageWriter* aWriter, const paramType& aParam) { 360 WriteParam(aWriter, aParam.mIdsOnX); 361 WriteParam(aWriter, aParam.mIdsOnY); 362 } 363 364 static bool Read(MessageReader* aReader, paramType* aResult) { 365 return ReadParam(aReader, &aResult->mIdsOnX) && 366 ReadParam(aReader, &aResult->mIdsOnY); 367 } 368 }; 369 370 template <> 371 struct ParamTraits<mozilla::layers::RepaintRequest> 372 : BitfieldHelper<mozilla::layers::RepaintRequest> { 373 typedef mozilla::layers::RepaintRequest paramType; 374 375 static void Write(MessageWriter* aWriter, const paramType& aParam) { 376 WriteParam(aWriter, aParam.mScrollId); 377 WriteParam(aWriter, aParam.mPresShellResolution); 378 WriteParam(aWriter, aParam.mCompositionBounds); 379 WriteParam(aWriter, aParam.mCumulativeResolution); 380 WriteParam(aWriter, aParam.mDevPixelsPerCSSPixel); 381 WriteParam(aWriter, aParam.mScrollOffset); 382 WriteParam(aWriter, aParam.mZoom); 383 WriteParam(aWriter, aParam.mScrollGeneration); 384 WriteParam(aWriter, aParam.mScrollGenerationOnApz); 385 WriteParam(aWriter, aParam.mDisplayPortMargins); 386 WriteParam(aWriter, aParam.mPresShellId); 387 WriteParam(aWriter, aParam.mLayoutViewport); 388 WriteParam(aWriter, aParam.mTransformToAncestorScale); 389 WriteParam(aWriter, aParam.mPaintRequestTime); 390 WriteParam(aWriter, aParam.mScrollUpdateType); 391 WriteParam(aWriter, aParam.mScrollAnimationType); 392 WriteParam(aWriter, aParam.mLastSnapTargetIds); 393 WriteParam(aWriter, aParam.mIsRootContent); 394 WriteParam(aWriter, aParam.mIsScrollInfoLayer); 395 WriteParam(aWriter, aParam.mIsInScrollingGesture); 396 } 397 398 static bool Read(MessageReader* aReader, paramType* aResult) { 399 return ( 400 ReadParam(aReader, &aResult->mScrollId) && 401 ReadParam(aReader, &aResult->mPresShellResolution) && 402 ReadParam(aReader, &aResult->mCompositionBounds) && 403 ReadParam(aReader, &aResult->mCumulativeResolution) && 404 ReadParam(aReader, &aResult->mDevPixelsPerCSSPixel) && 405 ReadParam(aReader, &aResult->mScrollOffset) && 406 ReadParam(aReader, &aResult->mZoom) && 407 ReadParam(aReader, &aResult->mScrollGeneration) && 408 ReadParam(aReader, &aResult->mScrollGenerationOnApz) && 409 ReadParam(aReader, &aResult->mDisplayPortMargins) && 410 ReadParam(aReader, &aResult->mPresShellId) && 411 ReadParam(aReader, &aResult->mLayoutViewport) && 412 ReadParam(aReader, &aResult->mTransformToAncestorScale) && 413 ReadParam(aReader, &aResult->mPaintRequestTime) && 414 ReadParam(aReader, &aResult->mScrollUpdateType) && 415 ReadParam(aReader, &aResult->mScrollAnimationType) && 416 ReadParam(aReader, &aResult->mLastSnapTargetIds) && 417 ReadBoolForBitfield(aReader, aResult, ¶mType::SetIsRootContent) && 418 ReadBoolForBitfield(aReader, aResult, 419 ¶mType::SetIsScrollInfoLayer) && 420 ReadBoolForBitfield(aReader, aResult, 421 ¶mType::SetIsInScrollingGesture)); 422 } 423 }; 424 425 template <> 426 struct ParamTraits<nsSize> { 427 typedef nsSize paramType; 428 429 static void Write(MessageWriter* aWriter, const paramType& aParam) { 430 WriteParam(aWriter, aParam.width); 431 WriteParam(aWriter, aParam.height); 432 } 433 434 static bool Read(MessageReader* aReader, paramType* aResult) { 435 return ReadParam(aReader, &aResult->width) && 436 ReadParam(aReader, &aResult->height); 437 } 438 }; 439 440 template <> 441 struct ParamTraits<mozilla::StyleScrollSnapStop> 442 : public ContiguousEnumSerializerInclusive< 443 mozilla::StyleScrollSnapStop, mozilla::StyleScrollSnapStop::Normal, 444 mozilla::StyleScrollSnapStop::Always> {}; 445 446 template <> 447 struct ParamTraits<mozilla::ScrollSnapTargetId> 448 : public ParamTraits_IsEnumCase<mozilla::ScrollSnapTargetId> {}; 449 450 template <> 451 struct ParamTraits<mozilla::SnapPoint> { 452 typedef mozilla::SnapPoint paramType; 453 454 static void Write(MessageWriter* aWriter, const paramType& aParam) { 455 WriteParam(aWriter, aParam.mX); 456 WriteParam(aWriter, aParam.mY); 457 } 458 459 static bool Read(MessageReader* aReader, paramType* aResult) { 460 return ReadParam(aReader, &aResult->mX) && ReadParam(aReader, &aResult->mY); 461 } 462 }; 463 464 template <> 465 struct ParamTraits<mozilla::ScrollSnapInfo::SnapTarget> { 466 typedef mozilla::ScrollSnapInfo::SnapTarget paramType; 467 468 static void Write(MessageWriter* aWriter, const paramType& aParam) { 469 WriteParam(aWriter, aParam.mSnapPoint); 470 WriteParam(aWriter, aParam.mSnapArea); 471 WriteParam(aWriter, aParam.mScrollSnapStop); 472 WriteParam(aWriter, aParam.mTargetId); 473 } 474 475 static bool Read(MessageReader* aReader, paramType* aResult) { 476 return ReadParam(aReader, &aResult->mSnapPoint) && 477 ReadParam(aReader, &aResult->mSnapArea) && 478 ReadParam(aReader, &aResult->mScrollSnapStop) && 479 ReadParam(aReader, &aResult->mTargetId); 480 } 481 }; 482 483 template <> 484 struct ParamTraits<mozilla::ScrollSnapInfo::ScrollSnapRange> { 485 typedef mozilla::ScrollSnapInfo::ScrollSnapRange paramType; 486 487 static void Write(MessageWriter* aWriter, const paramType& aParam) { 488 WriteParam(aWriter, aParam.mDirection); 489 WriteParam(aWriter, aParam.mSnapArea); 490 WriteParam(aWriter, aParam.mTargetId); 491 } 492 493 static bool Read(MessageReader* aReader, paramType* aResult) { 494 return ReadParam(aReader, &aResult->mDirection) && 495 ReadParam(aReader, &aResult->mSnapArea) && 496 ReadParam(aReader, &aResult->mTargetId); 497 } 498 }; 499 500 template <> 501 struct ParamTraits<mozilla::ScrollSnapInfo> { 502 typedef mozilla::ScrollSnapInfo paramType; 503 504 static void Write(MessageWriter* aWriter, const paramType& aParam) { 505 WriteParam(aWriter, aParam.mScrollSnapStrictnessX); 506 WriteParam(aWriter, aParam.mScrollSnapStrictnessY); 507 WriteParam(aWriter, aParam.mSnapTargets); 508 WriteParam(aWriter, aParam.mXRangeWiderThanSnapport); 509 WriteParam(aWriter, aParam.mYRangeWiderThanSnapport); 510 WriteParam(aWriter, aParam.mSnapportSize); 511 } 512 513 static bool Read(MessageReader* aReader, paramType* aResult) { 514 return (ReadParam(aReader, &aResult->mScrollSnapStrictnessX) && 515 ReadParam(aReader, &aResult->mScrollSnapStrictnessY) && 516 ReadParam(aReader, &aResult->mSnapTargets) && 517 ReadParam(aReader, &aResult->mXRangeWiderThanSnapport) && 518 ReadParam(aReader, &aResult->mYRangeWiderThanSnapport) && 519 ReadParam(aReader, &aResult->mSnapportSize)); 520 } 521 }; 522 523 template <> 524 struct ParamTraits<mozilla::layers::OverscrollBehaviorInfo> 525 : public ParamTraits_TiedFields<mozilla::layers::OverscrollBehaviorInfo> {}; 526 527 template <> 528 struct ParamTraits<mozilla::layers::OverflowInfo> 529 : public ParamTraits_TiedFields<mozilla::layers::OverflowInfo> {}; 530 531 template <typename T> 532 struct ParamTraits<mozilla::ScrollGeneration<T>> 533 : public ParamTraits_TiedFields<mozilla::ScrollGeneration<T>> {}; 534 535 template <> 536 struct ParamTraits<mozilla::ScrollUpdateType> 537 : public ContiguousEnumSerializerInclusive< 538 mozilla::ScrollUpdateType, mozilla::ScrollUpdateType::Absolute, 539 mozilla::ScrollUpdateType::PureRelative> {}; 540 541 template <> 542 struct ParamTraits<mozilla::ScrollMode> 543 : public ContiguousEnumSerializerInclusive<mozilla::ScrollMode, 544 mozilla::ScrollMode::Instant, 545 mozilla::ScrollMode::Normal> {}; 546 547 template <> 548 struct ParamTraits<mozilla::ScrollOrigin> 549 : public ContiguousEnumSerializerInclusive< 550 mozilla::ScrollOrigin, mozilla::ScrollOrigin::None, 551 mozilla::ScrollOrigin::Scrollbars> {}; 552 553 template <> 554 struct ParamTraits<mozilla::ScrollTriggeredByScript> 555 : public ContiguousEnumSerializerInclusive< 556 mozilla::ScrollTriggeredByScript, 557 mozilla::ScrollTriggeredByScript::No, 558 mozilla::ScrollTriggeredByScript::Yes> {}; 559 560 template <> 561 struct ParamTraits<mozilla::ViewportType> 562 : public ContiguousEnumSerializerInclusive<mozilla::ViewportType, 563 mozilla::ViewportType::Layout, 564 mozilla::ViewportType::Visual> { 565 }; 566 567 template <> 568 struct ParamTraits<mozilla::ScrollPositionUpdate> { 569 typedef mozilla::ScrollPositionUpdate paramType; 570 571 static void Write(MessageWriter* aWriter, const paramType& aParam) { 572 WriteParam(aWriter, aParam.mScrollGeneration); 573 WriteParam(aWriter, aParam.mType); 574 WriteParam(aWriter, aParam.mScrollMode); 575 WriteParam(aWriter, aParam.mScrollOrigin); 576 WriteParam(aWriter, aParam.mDestination); 577 WriteParam(aWriter, aParam.mSource); 578 WriteParam(aWriter, aParam.mDelta); 579 WriteParam(aWriter, aParam.mViewportType); 580 WriteParam(aWriter, aParam.mTriggeredByScript); 581 WriteParam(aWriter, aParam.mSnapTargetIds); 582 } 583 584 static bool Read(MessageReader* aReader, paramType* aResult) { 585 return ReadParam(aReader, &aResult->mScrollGeneration) && 586 ReadParam(aReader, &aResult->mType) && 587 ReadParam(aReader, &aResult->mScrollMode) && 588 ReadParam(aReader, &aResult->mScrollOrigin) && 589 ReadParam(aReader, &aResult->mDestination) && 590 ReadParam(aReader, &aResult->mSource) && 591 ReadParam(aReader, &aResult->mDelta) && 592 ReadParam(aReader, &aResult->mViewportType) && 593 ReadParam(aReader, &aResult->mTriggeredByScript) && 594 ReadParam(aReader, &aResult->mSnapTargetIds); 595 } 596 }; 597 598 template <> 599 struct ParamTraits<mozilla::dom::InteractiveWidget> 600 : public ContiguousEnumSerializerInclusive< 601 mozilla::dom::InteractiveWidget, 602 mozilla::dom::InteractiveWidget::OverlaysContent, 603 mozilla::dom::InteractiveWidget::ResizesVisual> {}; 604 605 template <> 606 struct ParamTraits<mozilla::layers::ScrollMetadata> 607 : BitfieldHelper<mozilla::layers::ScrollMetadata> { 608 typedef mozilla::layers::ScrollMetadata paramType; 609 610 static void Write(MessageWriter* aWriter, const paramType& aParam) { 611 WriteParam(aWriter, aParam.mMetrics); 612 WriteParam(aWriter, aParam.mSnapInfo); 613 WriteParam(aWriter, aParam.mScrollParentId); 614 WriteParam(aWriter, aParam.GetContentDescription()); 615 WriteParam(aWriter, aParam.mLineScrollAmount); 616 WriteParam(aWriter, aParam.mPageScrollAmount); 617 WriteParam(aWriter, aParam.mIsLayersIdRoot); 618 WriteParam(aWriter, aParam.mIsAutoDirRootContentRTL); 619 WriteParam(aWriter, aParam.mForceDisableApz); 620 WriteParam(aWriter, aParam.mResolutionUpdated); 621 WriteParam(aWriter, aParam.mIsRDMTouchSimulationActive); 622 WriteParam(aWriter, aParam.mDidContentGetPainted); 623 WriteParam(aWriter, aParam.mForceMousewheelAutodir); 624 WriteParam(aWriter, aParam.mForceMousewheelAutodirHonourRoot); 625 WriteParam(aWriter, aParam.mIsPaginatedPresentation); 626 WriteParam(aWriter, aParam.mDisregardedDirection); 627 WriteParam(aWriter, aParam.mOverscrollBehavior); 628 WriteParam(aWriter, aParam.mOverflow); 629 WriteParam(aWriter, aParam.mScrollUpdates); 630 } 631 632 static bool ReadContentDescription(MessageReader* aReader, 633 paramType* aResult) { 634 nsCString str; 635 if (!ReadParam(aReader, &str)) { 636 return false; 637 } 638 aResult->SetContentDescription(str); 639 return true; 640 } 641 642 static bool Read(MessageReader* aReader, paramType* aResult) { 643 return (ReadParam(aReader, &aResult->mMetrics) && 644 ReadParam(aReader, &aResult->mSnapInfo) && 645 ReadParam(aReader, &aResult->mScrollParentId) && 646 ReadContentDescription(aReader, aResult) && 647 ReadParam(aReader, &aResult->mLineScrollAmount) && 648 ReadParam(aReader, &aResult->mPageScrollAmount) && 649 ReadBoolForBitfield(aReader, aResult, 650 ¶mType::SetIsLayersIdRoot) && 651 ReadBoolForBitfield(aReader, aResult, 652 ¶mType::SetIsAutoDirRootContentRTL) && 653 ReadBoolForBitfield(aReader, aResult, 654 ¶mType::SetForceDisableApz) && 655 ReadBoolForBitfield(aReader, aResult, 656 ¶mType::SetResolutionUpdated) && 657 ReadBoolForBitfield(aReader, aResult, 658 ¶mType::SetIsRDMTouchSimulationActive)) && 659 ReadBoolForBitfield(aReader, aResult, 660 ¶mType::SetDidContentGetPainted) && 661 ReadBoolForBitfield(aReader, aResult, 662 ¶mType::SetForceMousewheelAutodir) && 663 ReadBoolForBitfield( 664 aReader, aResult, 665 ¶mType::SetForceMousewheelAutodirHonourRoot) && 666 ReadBoolForBitfield(aReader, aResult, 667 ¶mType::SetIsPaginatedPresentation) && 668 ReadParam(aReader, &aResult->mDisregardedDirection) && 669 ReadParam(aReader, &aResult->mOverscrollBehavior) && 670 ReadParam(aReader, &aResult->mOverflow) && 671 ReadParam(aReader, &aResult->mScrollUpdates); 672 } 673 }; 674 675 template <> 676 struct ParamTraits<mozilla::layers::TextureFactoryIdentifier> { 677 typedef mozilla::layers::TextureFactoryIdentifier paramType; 678 679 static void Write(MessageWriter* aWriter, const paramType& aParam) { 680 WriteParam(aWriter, aParam.mParentBackend); 681 WriteParam(aWriter, aParam.mWebRenderBackend); 682 WriteParam(aWriter, aParam.mWebRenderCompositor); 683 WriteParam(aWriter, aParam.mParentProcessType); 684 WriteParam(aWriter, aParam.mMaxTextureSize); 685 WriteParam(aWriter, aParam.mCompositorUseANGLE); 686 WriteParam(aWriter, aParam.mCompositorUseDComp); 687 WriteParam(aWriter, aParam.mUseLayerCompositor); 688 WriteParam(aWriter, aParam.mUseCompositorWnd); 689 WriteParam(aWriter, aParam.mSupportsTextureBlitting); 690 WriteParam(aWriter, aParam.mSupportsPartialUploads); 691 WriteParam(aWriter, aParam.mSupportsComponentAlpha); 692 WriteParam(aWriter, aParam.mSupportsD3D11NV12); 693 WriteParam(aWriter, aParam.mSyncHandle); 694 } 695 696 static bool Read(MessageReader* aReader, paramType* aResult) { 697 bool result = ReadParam(aReader, &aResult->mParentBackend) && 698 ReadParam(aReader, &aResult->mWebRenderBackend) && 699 ReadParam(aReader, &aResult->mWebRenderCompositor) && 700 ReadParam(aReader, &aResult->mParentProcessType) && 701 ReadParam(aReader, &aResult->mMaxTextureSize) && 702 ReadParam(aReader, &aResult->mCompositorUseANGLE) && 703 ReadParam(aReader, &aResult->mCompositorUseDComp) && 704 ReadParam(aReader, &aResult->mUseLayerCompositor) && 705 ReadParam(aReader, &aResult->mUseCompositorWnd) && 706 ReadParam(aReader, &aResult->mSupportsTextureBlitting) && 707 ReadParam(aReader, &aResult->mSupportsPartialUploads) && 708 ReadParam(aReader, &aResult->mSupportsComponentAlpha) && 709 ReadParam(aReader, &aResult->mSupportsD3D11NV12) && 710 ReadParam(aReader, &aResult->mSyncHandle); 711 return result; 712 } 713 }; 714 715 template <> 716 struct ParamTraits<mozilla::layers::TextureInfo> { 717 typedef mozilla::layers::TextureInfo paramType; 718 719 static void Write(MessageWriter* aWriter, const paramType& aParam) { 720 WriteParam(aWriter, aParam.mCompositableType); 721 WriteParam(aWriter, aParam.mUsageType); 722 WriteParam(aWriter, aParam.mTextureFlags); 723 } 724 725 static bool Read(MessageReader* aReader, paramType* aResult) { 726 return ReadParam(aReader, &aResult->mCompositableType) && 727 ReadParam(aReader, &aResult->mUsageType) && 728 ReadParam(aReader, &aResult->mTextureFlags); 729 } 730 }; 731 732 template <> 733 struct ParamTraits<mozilla::layers::CompositableType> 734 : public ContiguousEnumSerializer< 735 mozilla::layers::CompositableType, 736 mozilla::layers::CompositableType::UNKNOWN, 737 mozilla::layers::CompositableType::COUNT> {}; 738 739 template <> 740 struct ParamTraits<mozilla::layers::ImageUsageType> 741 : public ContiguousEnumSerializer<mozilla::layers::ImageUsageType, 742 mozilla::layers::ImageUsageType::UNKNOWN, 743 mozilla::layers::ImageUsageType::COUNT> { 744 }; 745 746 template <> 747 struct ParamTraits<mozilla::layers::ScrollableLayerGuid> { 748 typedef mozilla::layers::ScrollableLayerGuid paramType; 749 750 static void Write(MessageWriter* aWriter, const paramType& aParam) { 751 WriteParam(aWriter, aParam.mLayersId); 752 WriteParam(aWriter, aParam.mPresShellId); 753 WriteParam(aWriter, aParam.mScrollId); 754 } 755 756 static bool Read(MessageReader* aReader, paramType* aResult) { 757 return (ReadParam(aReader, &aResult->mLayersId) && 758 ReadParam(aReader, &aResult->mPresShellId) && 759 ReadParam(aReader, &aResult->mScrollId)); 760 } 761 }; 762 763 template <> 764 struct ParamTraits<nsEventStatus> 765 : public ContiguousEnumSerializer<nsEventStatus, nsEventStatus_eIgnore, 766 nsEventStatus_eSentinel> {}; 767 768 template <> 769 struct ParamTraits<mozilla::layers::APZHandledPlace> 770 : public ContiguousEnumSerializer< 771 mozilla::layers::APZHandledPlace, 772 mozilla::layers::APZHandledPlace::Unhandled, 773 mozilla::layers::APZHandledPlace::Last> {}; 774 775 template <> 776 struct ParamTraits<mozilla::layers::ScrollDirections> { 777 typedef mozilla::layers::ScrollDirections paramType; 778 779 static void Write(MessageWriter* aWriter, const paramType& aParam) { 780 WriteParam(aWriter, aParam.serialize()); 781 } 782 783 static bool Read(MessageReader* aReader, paramType* aResult) { 784 uint8_t value; 785 if (!ReadParam(aReader, &value)) { 786 return false; 787 } 788 aResult->deserialize(value); 789 return true; 790 } 791 }; 792 793 template <> 794 struct ParamTraits<mozilla::layers::APZHandledResult> { 795 typedef mozilla::layers::APZHandledResult paramType; 796 797 static void Write(MessageWriter* aWriter, const paramType& aParam) { 798 WriteParam(aWriter, aParam.mPlace); 799 WriteParam(aWriter, aParam.mScrollableDirections); 800 WriteParam(aWriter, aParam.mOverscrollDirections); 801 } 802 803 static bool Read(MessageReader* aReader, paramType* aResult) { 804 return (ReadParam(aReader, &aResult->mPlace) && 805 ReadParam(aReader, &aResult->mScrollableDirections) && 806 ReadParam(aReader, &aResult->mOverscrollDirections)); 807 } 808 }; 809 810 template <> 811 struct ParamTraits<mozilla::layers::APZEventResult> { 812 typedef mozilla::layers::APZEventResult paramType; 813 814 static void Write(MessageWriter* aWriter, const paramType& aParam) { 815 WriteParam(aWriter, aParam.GetStatus()); 816 WriteParam(aWriter, aParam.GetHandledResult()); 817 WriteParam(aWriter, aParam.mTargetGuid); 818 WriteParam(aWriter, aParam.mInputBlockId); 819 } 820 821 static bool Read(MessageReader* aReader, paramType* aResult) { 822 nsEventStatus status; 823 if (!ReadParam(aReader, &status)) { 824 return false; 825 } 826 aResult->UpdateStatus(status); 827 828 mozilla::Maybe<mozilla::layers::APZHandledResult> handledResult; 829 if (!ReadParam(aReader, &handledResult)) { 830 return false; 831 } 832 aResult->UpdateHandledResult(handledResult); 833 834 return (ReadParam(aReader, &aResult->mTargetGuid) && 835 ReadParam(aReader, &aResult->mInputBlockId)); 836 } 837 }; 838 839 template <> 840 struct ParamTraits<mozilla::layers::ZoomConstraints> { 841 typedef mozilla::layers::ZoomConstraints paramType; 842 843 static void Write(MessageWriter* aWriter, const paramType& aParam) { 844 WriteParam(aWriter, aParam.mAllowZoom); 845 WriteParam(aWriter, aParam.mAllowDoubleTapZoom); 846 WriteParam(aWriter, aParam.mMinZoom); 847 WriteParam(aWriter, aParam.mMaxZoom); 848 } 849 850 static bool Read(MessageReader* aReader, paramType* aResult) { 851 return (ReadParam(aReader, &aResult->mAllowZoom) && 852 ReadParam(aReader, &aResult->mAllowDoubleTapZoom) && 853 ReadParam(aReader, &aResult->mMinZoom) && 854 ReadParam(aReader, &aResult->mMaxZoom)); 855 } 856 }; 857 858 template <> 859 struct ParamTraits<mozilla::layers::FocusTarget::ScrollTargets> { 860 typedef mozilla::layers::FocusTarget::ScrollTargets paramType; 861 862 static void Write(MessageWriter* aWriter, const paramType& aParam) { 863 WriteParam(aWriter, aParam.mHorizontal); 864 WriteParam(aWriter, aParam.mVertical); 865 } 866 867 static bool Read(MessageReader* aReader, paramType* aResult) { 868 return ReadParam(aReader, &aResult->mHorizontal) && 869 ReadParam(aReader, &aResult->mVertical); 870 } 871 }; 872 873 template <> 874 struct ParamTraits<mozilla::layers::FocusTarget::NoFocusTarget> 875 : public EmptyStructSerializer< 876 mozilla::layers::FocusTarget::NoFocusTarget> {}; 877 878 template <> 879 struct ParamTraits<mozilla::layers::FocusTarget> { 880 typedef mozilla::layers::FocusTarget paramType; 881 882 static void Write(MessageWriter* aWriter, const paramType& aParam) { 883 WriteParam(aWriter, aParam.mSequenceNumber); 884 WriteParam(aWriter, aParam.mFocusHasKeyEventListeners); 885 WriteParam(aWriter, aParam.mData); 886 } 887 888 static bool Read(MessageReader* aReader, paramType* aResult) { 889 if (!ReadParam(aReader, &aResult->mSequenceNumber) || 890 !ReadParam(aReader, &aResult->mFocusHasKeyEventListeners) || 891 !ReadParam(aReader, &aResult->mData)) { 892 return false; 893 } 894 return true; 895 } 896 }; 897 898 template <> 899 struct ParamTraits< 900 mozilla::layers::KeyboardScrollAction::KeyboardScrollActionType> 901 : public ContiguousEnumSerializerInclusive< 902 mozilla::layers::KeyboardScrollAction::KeyboardScrollActionType, 903 mozilla::layers::KeyboardScrollAction::KeyboardScrollActionType:: 904 eScrollCharacter, 905 mozilla::layers::KeyboardScrollAction:: 906 sHighestKeyboardScrollActionType> {}; 907 908 template <> 909 struct ParamTraits<mozilla::layers::KeyboardScrollAction> { 910 typedef mozilla::layers::KeyboardScrollAction paramType; 911 912 static void Write(MessageWriter* aWriter, const paramType& aParam) { 913 WriteParam(aWriter, aParam.mType); 914 WriteParam(aWriter, aParam.mForward); 915 } 916 917 static bool Read(MessageReader* aReader, paramType* aResult) { 918 return ReadParam(aReader, &aResult->mType) && 919 ReadParam(aReader, &aResult->mForward); 920 } 921 }; 922 923 template <> 924 struct ParamTraits<mozilla::layers::KeyboardShortcut> { 925 typedef mozilla::layers::KeyboardShortcut paramType; 926 927 static void Write(MessageWriter* aWriter, const paramType& aParam) { 928 WriteParam(aWriter, aParam.mAction); 929 WriteParam(aWriter, aParam.mKeyCode); 930 WriteParam(aWriter, aParam.mCharCode); 931 WriteParam(aWriter, aParam.mModifiers); 932 WriteParam(aWriter, aParam.mModifiersMask); 933 WriteParam(aWriter, aParam.mEventType); 934 WriteParam(aWriter, aParam.mDispatchToContent); 935 } 936 937 static bool Read(MessageReader* aReader, paramType* aResult) { 938 return ReadParam(aReader, &aResult->mAction) && 939 ReadParam(aReader, &aResult->mKeyCode) && 940 ReadParam(aReader, &aResult->mCharCode) && 941 ReadParam(aReader, &aResult->mModifiers) && 942 ReadParam(aReader, &aResult->mModifiersMask) && 943 ReadParam(aReader, &aResult->mEventType) && 944 ReadParam(aReader, &aResult->mDispatchToContent); 945 } 946 }; 947 948 template <> 949 struct ParamTraits<mozilla::layers::KeyboardMap> { 950 typedef mozilla::layers::KeyboardMap paramType; 951 952 static void Write(MessageWriter* aWriter, const paramType& aParam) { 953 WriteParam(aWriter, aParam.Shortcuts()); 954 } 955 956 static bool Read(MessageReader* aReader, paramType* aResult) { 957 nsTArray<mozilla::layers::KeyboardShortcut> shortcuts; 958 if (!ReadParam(aReader, &shortcuts)) { 959 return false; 960 } 961 *aResult = mozilla::layers::KeyboardMap(std::move(shortcuts)); 962 return true; 963 } 964 }; 965 966 template <> 967 struct ParamTraits<mozilla::layers::GeckoContentController_TapType> 968 : public ContiguousEnumSerializerInclusive< 969 mozilla::layers::GeckoContentController_TapType, 970 mozilla::layers::GeckoContentController_TapType::eSingleTap, 971 mozilla::layers::kHighestGeckoContentController_TapType> {}; 972 973 template <> 974 struct ParamTraits<mozilla::layers::GeckoContentController_APZStateChange> 975 : public ContiguousEnumSerializerInclusive< 976 mozilla::layers::GeckoContentController_APZStateChange, 977 mozilla::layers::GeckoContentController_APZStateChange:: 978 eTransformBegin, 979 mozilla::layers::kHighestGeckoContentController_APZStateChange> {}; 980 981 template <> 982 struct ParamTraits<mozilla::layers::EventRegionsOverride> 983 : public BitFlagsEnumSerializer< 984 mozilla::layers::EventRegionsOverride, 985 mozilla::layers::EventRegionsOverride::ALL_BITS> {}; 986 987 template <> 988 struct ParamTraits<mozilla::layers::AsyncDragMetrics> { 989 typedef mozilla::layers::AsyncDragMetrics paramType; 990 991 static void Write(MessageWriter* aWriter, const paramType& aParam) { 992 WriteParam(aWriter, aParam.mViewId); 993 WriteParam(aWriter, aParam.mPresShellId); 994 WriteParam(aWriter, aParam.mDragStartSequenceNumber); 995 WriteParam(aWriter, aParam.mScrollbarDragOffset); 996 WriteParam(aWriter, aParam.mDirection); 997 } 998 999 static bool Read(MessageReader* aReader, paramType* aResult) { 1000 return (ReadParam(aReader, &aResult->mViewId) && 1001 ReadParam(aReader, &aResult->mPresShellId) && 1002 ReadParam(aReader, &aResult->mDragStartSequenceNumber) && 1003 ReadParam(aReader, &aResult->mScrollbarDragOffset) && 1004 ReadParam(aReader, &aResult->mDirection)); 1005 } 1006 }; 1007 1008 template <> 1009 struct ParamTraits<mozilla::layers::BrowserGestureResponse> 1010 : public ContiguousEnumSerializerInclusive< 1011 mozilla::layers::BrowserGestureResponse, 1012 mozilla::layers::BrowserGestureResponse::NotConsumed, 1013 mozilla::layers::BrowserGestureResponse::Consumed> {}; 1014 1015 template <> 1016 struct ParamTraits<mozilla::layers::CompositorOptions> { 1017 typedef mozilla::layers::CompositorOptions paramType; 1018 1019 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1020 WriteParam(aWriter, aParam.mUseAPZ); 1021 WriteParam(aWriter, aParam.mUseSoftwareWebRender); 1022 WriteParam(aWriter, aParam.mAllowSoftwareWebRenderD3D11); 1023 WriteParam(aWriter, aParam.mAllowSoftwareWebRenderOGL); 1024 WriteParam(aWriter, aParam.mInitiallyPaused); 1025 WriteParam(aWriter, aParam.mNeedFastSnaphot); 1026 WriteParam(aWriter, aParam.mAllowNativeCompositor); 1027 } 1028 1029 static bool Read(MessageReader* aReader, paramType* aResult) { 1030 return ReadParam(aReader, &aResult->mUseAPZ) && 1031 ReadParam(aReader, &aResult->mUseSoftwareWebRender) && 1032 ReadParam(aReader, &aResult->mAllowSoftwareWebRenderD3D11) && 1033 ReadParam(aReader, &aResult->mAllowSoftwareWebRenderOGL) && 1034 ReadParam(aReader, &aResult->mInitiallyPaused) && 1035 ReadParam(aReader, &aResult->mNeedFastSnaphot) && 1036 ReadParam(aReader, &aResult->mAllowNativeCompositor); 1037 } 1038 }; 1039 1040 template <> 1041 struct ParamTraits<mozilla::layers::OverlaySupportType> 1042 : public ContiguousEnumSerializerInclusive< 1043 mozilla::layers::OverlaySupportType, 1044 mozilla::layers::OverlaySupportType::None, 1045 mozilla::layers::OverlaySupportType::MAX> {}; 1046 1047 template <> 1048 struct ParamTraits<mozilla::layers::OverlayInfo> { 1049 typedef mozilla::layers::OverlayInfo paramType; 1050 1051 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1052 WriteParam(aWriter, aParam.mSupportsOverlays); 1053 WriteParam(aWriter, aParam.mNv12Overlay); 1054 WriteParam(aWriter, aParam.mYuy2Overlay); 1055 WriteParam(aWriter, aParam.mBgra8Overlay); 1056 WriteParam(aWriter, aParam.mRgb10a2Overlay); 1057 WriteParam(aWriter, aParam.mRgba16fOverlay); 1058 WriteParam(aWriter, aParam.mSupportsVpSuperResolution); 1059 WriteParam(aWriter, aParam.mSupportsVpAutoHDR); 1060 WriteParam(aWriter, aParam.mSupportsHDR); 1061 } 1062 1063 static bool Read(MessageReader* aReader, paramType* aResult) { 1064 return ReadParam(aReader, &aResult->mSupportsOverlays) && 1065 ReadParam(aReader, &aResult->mNv12Overlay) && 1066 ReadParam(aReader, &aResult->mYuy2Overlay) && 1067 ReadParam(aReader, &aResult->mBgra8Overlay) && 1068 ReadParam(aReader, &aResult->mRgb10a2Overlay) && 1069 ReadParam(aReader, &aResult->mRgba16fOverlay) && 1070 ReadParam(aReader, &aResult->mSupportsVpSuperResolution) && 1071 ReadParam(aReader, &aResult->mSupportsVpAutoHDR) && 1072 ReadParam(aReader, &aResult->mSupportsHDR); 1073 } 1074 }; 1075 1076 template <> 1077 struct ParamTraits<mozilla::layers::SwapChainInfo> { 1078 typedef mozilla::layers::SwapChainInfo paramType; 1079 1080 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1081 WriteParam(aWriter, aParam.mTearingSupported); 1082 } 1083 1084 static bool Read(MessageReader* aReader, paramType* aResult) { 1085 return ReadParam(aReader, &aResult->mTearingSupported); 1086 } 1087 }; 1088 1089 template <> 1090 struct ParamTraits<mozilla::layers::ScrollbarLayerType> 1091 : public ContiguousEnumSerializerInclusive< 1092 mozilla::layers::ScrollbarLayerType, 1093 mozilla::layers::ScrollbarLayerType::None, 1094 mozilla::layers::kHighestScrollbarLayerType> {}; 1095 1096 template <> 1097 struct ParamTraits<mozilla::layers::ScrollbarData> { 1098 typedef mozilla::layers::ScrollbarData paramType; 1099 1100 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1101 WriteParam(aWriter, aParam.mDirection); 1102 WriteParam(aWriter, aParam.mScrollbarLayerType); 1103 WriteParam(aWriter, aParam.mThumbRatio); 1104 WriteParam(aWriter, aParam.mThumbStart); 1105 WriteParam(aWriter, aParam.mThumbLength); 1106 WriteParam(aWriter, aParam.mThumbMinLength); 1107 WriteParam(aWriter, aParam.mThumbIsAsyncDraggable); 1108 WriteParam(aWriter, aParam.mScrollTrackStart); 1109 WriteParam(aWriter, aParam.mScrollTrackLength); 1110 WriteParam(aWriter, aParam.mTargetViewId); 1111 } 1112 1113 static bool Read(MessageReader* aReader, paramType* aResult) { 1114 return ReadParam(aReader, &aResult->mDirection) && 1115 ReadParam(aReader, &aResult->mScrollbarLayerType) && 1116 ReadParam(aReader, &aResult->mThumbRatio) && 1117 ReadParam(aReader, &aResult->mThumbStart) && 1118 ReadParam(aReader, &aResult->mThumbLength) && 1119 ReadParam(aReader, &aResult->mThumbMinLength) && 1120 ReadParam(aReader, &aResult->mThumbIsAsyncDraggable) && 1121 ReadParam(aReader, &aResult->mScrollTrackStart) && 1122 ReadParam(aReader, &aResult->mScrollTrackLength) && 1123 ReadParam(aReader, &aResult->mTargetViewId); 1124 } 1125 }; 1126 1127 template <> 1128 struct ParamTraits<mozilla::layers::CompositionPayloadType> 1129 : public ContiguousEnumSerializerInclusive< 1130 mozilla::layers::CompositionPayloadType, 1131 mozilla::layers::CompositionPayloadType::eKeyPress, 1132 mozilla::layers::kHighestCompositionPayloadType> {}; 1133 1134 template <> 1135 struct ParamTraits<mozilla::layers::CompositionPayload> { 1136 typedef mozilla::layers::CompositionPayload paramType; 1137 1138 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1139 WriteParam(aWriter, aParam.mType); 1140 WriteParam(aWriter, aParam.mTimeStamp); 1141 } 1142 1143 static bool Read(MessageReader* aReader, paramType* aResult) { 1144 return ReadParam(aReader, &aResult->mType) && 1145 ReadParam(aReader, &aResult->mTimeStamp); 1146 } 1147 }; 1148 1149 template <> 1150 struct ParamTraits<mozilla::layers::ClearImagesType> 1151 : public ContiguousEnumSerializerInclusive< 1152 mozilla::layers::ClearImagesType, 1153 mozilla::layers::ClearImagesType::All, 1154 mozilla::layers::ClearImagesType::CacheOnly> {}; 1155 1156 template <> 1157 struct ParamTraits<mozilla::layers::CantZoomOutBehavior> 1158 : public ContiguousEnumSerializerInclusive< 1159 mozilla::layers::CantZoomOutBehavior, 1160 mozilla::layers::CantZoomOutBehavior::Nothing, 1161 mozilla::layers::CantZoomOutBehavior::ZoomIn> {}; 1162 1163 template <> 1164 struct ParamTraits<mozilla::layers::ZoomTarget> { 1165 typedef mozilla::layers::ZoomTarget paramType; 1166 1167 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1168 WriteParam(aWriter, aParam.targetRect); 1169 WriteParam(aWriter, aParam.cantZoomOutBehavior); 1170 WriteParam(aWriter, aParam.elementBoundingRect); 1171 WriteParam(aWriter, aParam.documentRelativePointerPosition); 1172 } 1173 1174 static bool Read(MessageReader* aReader, paramType* aResult) { 1175 return (ReadParam(aReader, &aResult->targetRect) && 1176 ReadParam(aReader, &aResult->cantZoomOutBehavior) && 1177 ReadParam(aReader, &aResult->elementBoundingRect) && 1178 ReadParam(aReader, &aResult->documentRelativePointerPosition)); 1179 } 1180 }; 1181 1182 template <> 1183 struct ParamTraits<mozilla::layers::DoubleTapToZoomMetrics> { 1184 typedef mozilla::layers::DoubleTapToZoomMetrics paramType; 1185 1186 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1187 WriteParam(aWriter, aParam.mVisualViewport); 1188 WriteParam(aWriter, aParam.mRootScrollableRect); 1189 WriteParam(aWriter, aParam.mTransformMatrix); 1190 } 1191 1192 static bool Read(MessageReader* aReader, paramType* aResult) { 1193 return (ReadParam(aReader, &aResult->mVisualViewport) && 1194 ReadParam(aReader, &aResult->mRootScrollableRect) && 1195 ReadParam(aReader, &aResult->mTransformMatrix)); 1196 } 1197 }; 1198 1199 template <> 1200 struct ParamTraits<mozilla::layers::CompositorScrollUpdate::Source> 1201 : public ContiguousEnumSerializerInclusive< 1202 mozilla::layers::CompositorScrollUpdate::Source, 1203 mozilla::layers::CompositorScrollUpdate::Source::UserInteraction, 1204 mozilla::layers::CompositorScrollUpdate::Source::Other> {}; 1205 1206 template <> 1207 struct ParamTraits<mozilla::layers::CompositorScrollUpdate::Metrics> { 1208 typedef mozilla::layers::CompositorScrollUpdate::Metrics paramType; 1209 1210 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1211 WriteParam(aWriter, aParam.mVisualScrollOffset); 1212 WriteParam(aWriter, aParam.mZoom); 1213 } 1214 1215 static bool Read(MessageReader* aReader, paramType* aResult) { 1216 return (ReadParam(aReader, &aResult->mVisualScrollOffset) && 1217 ReadParam(aReader, &aResult->mZoom)); 1218 } 1219 }; 1220 1221 template <> 1222 struct ParamTraits<mozilla::layers::CompositorScrollUpdate> { 1223 typedef mozilla::layers::CompositorScrollUpdate paramType; 1224 1225 static void Write(MessageWriter* aWriter, const paramType& aParam) { 1226 WriteParam(aWriter, aParam.mMetrics); 1227 WriteParam(aWriter, aParam.mSource); 1228 } 1229 1230 static bool Read(MessageReader* aReader, paramType* aResult) { 1231 return (ReadParam(aReader, &aResult->mMetrics) && 1232 ReadParam(aReader, &aResult->mSource)); 1233 } 1234 }; 1235 1236 template <> 1237 struct ParamTraits<mozilla::layers::GpuFence*> { 1238 static void Write(MessageWriter* aWriter, mozilla::layers::GpuFence* aParam) { 1239 if (aParam) { 1240 MOZ_ASSERT_UNREACHABLE("unexpected to be called"); 1241 } 1242 WriteParam(aWriter, false); 1243 } 1244 1245 static bool Read(MessageReader* aReader, 1246 RefPtr<mozilla::layers::GpuFence>* aResult) { 1247 *aResult = nullptr; 1248 bool notnull = false; 1249 if (!ReadParam(aReader, ¬null)) { 1250 return false; 1251 } 1252 1253 if (!notnull) { 1254 return true; 1255 } 1256 1257 MOZ_ASSERT_UNREACHABLE("unexpected to be called"); 1258 return true; 1259 } 1260 }; 1261 1262 } /* namespace IPC */ 1263 1264 #define DEFINE_SERVO_PARAMTRAITS(ty_) \ 1265 MOZ_DEFINE_RUST_PARAMTRAITS(mozilla::ty_, Servo_##ty_##_Serialize, \ 1266 Servo_##ty_##_Deserialize) 1267 1268 DEFINE_SERVO_PARAMTRAITS(LengthPercentage) 1269 DEFINE_SERVO_PARAMTRAITS(StyleOffsetPath) 1270 DEFINE_SERVO_PARAMTRAITS(StyleOffsetRotate) 1271 DEFINE_SERVO_PARAMTRAITS(StylePositionOrAuto) 1272 DEFINE_SERVO_PARAMTRAITS(StyleOffsetPosition) 1273 DEFINE_SERVO_PARAMTRAITS(StyleRotate) 1274 DEFINE_SERVO_PARAMTRAITS(StyleScale) 1275 DEFINE_SERVO_PARAMTRAITS(StyleTranslate) 1276 DEFINE_SERVO_PARAMTRAITS(StyleTransform) 1277 DEFINE_SERVO_PARAMTRAITS(StyleComputedTimingFunction) 1278 1279 #undef DEFINE_SERVO_PARAMTRAITS 1280 1281 #endif /* mozilla_layers_LayersMessageUtils */