widget/nsGUIEventIPC.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef nsGUIEventIPC_h__
   7 #define nsGUIEventIPC_h__
   8
   9 #include "ipc/IPCMessageUtils.h"
  10 #include "mozilla/ContentCache.h"
  11 #include "mozilla/GfxMessageUtils.h"
  12 #include "mozilla/dom/Touch.h"
  13 #include "mozilla/MiscEvents.h"
  14 #include "mozilla/MouseEvents.h"
  15 #include "mozilla/TextEvents.h"
  16 #include "mozilla/TouchEvents.h"
  17 #include "mozilla/WheelHandlingHelper.h"  // for WheelDeltaAdjustmentStrategy
  18 #include "mozilla/dom/Selection.h"
  19 #include "InputData.h"
  20
  21 namespace IPC {
  22
  23 template <>
  24 struct ParamTraits<mozilla::EventMessage>
  25     : public ContiguousEnumSerializer<
  26           mozilla::EventMessage, mozilla::EventMessage(0),
  27           mozilla::EventMessage::eEventMessage_MaxValue> {};
  28
  29 template <>
  30 struct ParamTraits<mozilla::BaseEventFlags> {
  31   typedef mozilla::BaseEventFlags paramType;
  32
  33   static void Write(Message* aMsg, const paramType& aParam) {
  34     aMsg->WriteBytes(&aParam, sizeof(aParam));
  35   }
  36
  37   static bool Read(const Message* aMsg, PickleIterator* aIter,
  38                    paramType* aResult) {
  39     return aMsg->ReadBytesInto(aIter, aResult, sizeof(*aResult));
  40   }
  41 };
  42
  43 template <>
  44 struct ParamTraits<mozilla::WidgetEvent> {
  45   typedef mozilla::WidgetEvent paramType;
  46
  47   static void Write(Message* aMsg, const paramType& aParam) {
  48     // Mark the event as posted to another process.
  49     const_cast<mozilla::WidgetEvent&>(aParam).MarkAsPostedToRemoteProcess();
  50
  51     WriteParam(aMsg, static_cast<mozilla::EventClassIDType>(aParam.mClass));
  52     WriteParam(aMsg, aParam.mMessage);
  53     WriteParam(aMsg, aParam.mRefPoint);
  54     WriteParam(aMsg, aParam.mFocusSequenceNumber);
  55     WriteParam(aMsg, aParam.mTime);
  56     WriteParam(aMsg, aParam.mTimeStamp);
  57     WriteParam(aMsg, aParam.mFlags);
  58     WriteParam(aMsg, aParam.mLayersId);
  59   }
  60
  61   static bool Read(const Message* aMsg, PickleIterator* aIter,
  62                    paramType* aResult) {
  63     mozilla::EventClassIDType eventClassID = 0;
  64     bool ret = ReadParam(aMsg, aIter, &eventClassID) &&
  65                ReadParam(aMsg, aIter, &aResult->mMessage) &&
  66                ReadParam(aMsg, aIter, &aResult->mRefPoint) &&
  67                ReadParam(aMsg, aIter, &aResult->mFocusSequenceNumber) &&
  68                ReadParam(aMsg, aIter, &aResult->mTime) &&
  69                ReadParam(aMsg, aIter, &aResult->mTimeStamp) &&
  70                ReadParam(aMsg, aIter, &aResult->mFlags) &&
  71                ReadParam(aMsg, aIter, &aResult->mLayersId);
  72     aResult->mClass = static_cast<mozilla::EventClassID>(eventClassID);
  73     if (ret) {
  74       // Reset cross process dispatching state here because the event has not
  75       // been dispatched to different process from current process.
  76       aResult->ResetCrossProcessDispatchingState();
  77       // Mark the event comes from another process.
  78       aResult->MarkAsComingFromAnotherProcess();
  79     }
  80     return ret;
  81   }
  82 };
  83
  84 template <>
  85 struct ParamTraits<mozilla::NativeEventData> {
  86   typedef mozilla::NativeEventData paramType;
  87
  88   static void Write(Message* aMsg, const paramType& aParam) {
  89     WriteParam(aMsg, aParam.mBuffer);
  90   }
  91
  92   static bool Read(const Message* aMsg, PickleIterator* aIter,
  93                    paramType* aResult) {
  94     return ReadParam(aMsg, aIter, &aResult->mBuffer);
  95   }
  96 };
  97
  98 template <>
  99 struct ParamTraits<mozilla::WidgetGUIEvent> {
 100   typedef mozilla::WidgetGUIEvent paramType;
 101
 102   static void Write(Message* aMsg, const paramType& aParam) {
 103     WriteParam(aMsg, static_cast<const mozilla::WidgetEvent&>(aParam));
 104     WriteParam(aMsg, aParam.mPluginEvent);
 105   }
 106
 107   static bool Read(const Message* aMsg, PickleIterator* aIter,
 108                    paramType* aResult) {
 109     return ReadParam(aMsg, aIter,
 110                      static_cast<mozilla::WidgetEvent*>(aResult)) &&
 111            ReadParam(aMsg, aIter, &aResult->mPluginEvent);
 112   }
 113 };
 114
 115 template <>
 116 struct ParamTraits<mozilla::WidgetInputEvent> {
 117   typedef mozilla::WidgetInputEvent paramType;
 118
 119   static void Write(Message* aMsg, const paramType& aParam) {
 120     WriteParam(aMsg, static_cast<const mozilla::WidgetGUIEvent&>(aParam));
 121     WriteParam(aMsg, aParam.mModifiers);
 122   }
 123
 124   static bool Read(const Message* aMsg, PickleIterator* aIter,
 125                    paramType* aResult) {
 126     return ReadParam(aMsg, aIter,
 127                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 128            ReadParam(aMsg, aIter, &aResult->mModifiers);
 129   }
 130 };
 131
 132 template <>
 133 struct ParamTraits<mozilla::WidgetMouseEventBase> {
 134   typedef mozilla::WidgetMouseEventBase paramType;
 135
 136   static void Write(Message* aMsg, const paramType& aParam) {
 137     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 138     WriteParam(aMsg, aParam.mButton);
 139     WriteParam(aMsg, aParam.mButtons);
 140     WriteParam(aMsg, aParam.mPressure);
 141     WriteParam(aMsg, aParam.mInputSource);
 142   }
 143
 144   static bool Read(const Message* aMsg, PickleIterator* aIter,
 145                    paramType* aResult) {
 146     return ReadParam(aMsg, aIter,
 147                      static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 148            ReadParam(aMsg, aIter, &aResult->mButton) &&
 149            ReadParam(aMsg, aIter, &aResult->mButtons) &&
 150            ReadParam(aMsg, aIter, &aResult->mPressure) &&
 151            ReadParam(aMsg, aIter, &aResult->mInputSource);
 152   }
 153 };
 154
 155 template <>
 156 struct ParamTraits<mozilla::WidgetWheelEvent> {
 157   typedef mozilla::WidgetWheelEvent paramType;
 158
 159   static void Write(Message* aMsg, const paramType& aParam) {
 160     WriteParam(aMsg, static_cast<const mozilla::WidgetMouseEventBase&>(aParam));
 161     WriteParam(aMsg, aParam.mDeltaX);
 162     WriteParam(aMsg, aParam.mDeltaY);
 163     WriteParam(aMsg, aParam.mDeltaZ);
 164     WriteParam(aMsg, aParam.mDeltaMode);
 165     WriteParam(aMsg, aParam.mCustomizedByUserPrefs);
 166     WriteParam(aMsg, aParam.mMayHaveMomentum);
 167     WriteParam(aMsg, aParam.mIsMomentum);
 168     WriteParam(aMsg, aParam.mIsNoLineOrPageDelta);
 169     WriteParam(aMsg, aParam.mLineOrPageDeltaX);
 170     WriteParam(aMsg, aParam.mLineOrPageDeltaY);
 171     WriteParam(aMsg, static_cast<uint8_t>(aParam.mScrollType));
 172     WriteParam(aMsg, aParam.mOverflowDeltaX);
 173     WriteParam(aMsg, aParam.mOverflowDeltaY);
 174     WriteParam(aMsg, aParam.mViewPortIsOverscrolled);
 175     WriteParam(aMsg, aParam.mCanTriggerSwipe);
 176     WriteParam(aMsg, aParam.mAllowToOverrideSystemScrollSpeed);
 177     WriteParam(aMsg, aParam.mDeltaValuesHorizontalizedForDefaultHandler);
 178   }
 179
 180   static bool Read(const Message* aMsg, PickleIterator* aIter,
 181                    paramType* aResult) {
 182     uint8_t scrollType = 0;
 183     bool rv =
 184         ReadParam(aMsg, aIter,
 185                   static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 186         ReadParam(aMsg, aIter, &aResult->mDeltaX) &&
 187         ReadParam(aMsg, aIter, &aResult->mDeltaY) &&
 188         ReadParam(aMsg, aIter, &aResult->mDeltaZ) &&
 189         ReadParam(aMsg, aIter, &aResult->mDeltaMode) &&
 190         ReadParam(aMsg, aIter, &aResult->mCustomizedByUserPrefs) &&
 191         ReadParam(aMsg, aIter, &aResult->mMayHaveMomentum) &&
 192         ReadParam(aMsg, aIter, &aResult->mIsMomentum) &&
 193         ReadParam(aMsg, aIter, &aResult->mIsNoLineOrPageDelta) &&
 194         ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaX) &&
 195         ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaY) &&
 196         ReadParam(aMsg, aIter, &scrollType) &&
 197         ReadParam(aMsg, aIter, &aResult->mOverflowDeltaX) &&
 198         ReadParam(aMsg, aIter, &aResult->mOverflowDeltaY) &&
 199         ReadParam(aMsg, aIter, &aResult->mViewPortIsOverscrolled) &&
 200         ReadParam(aMsg, aIter, &aResult->mCanTriggerSwipe) &&
 201         ReadParam(aMsg, aIter, &aResult->mAllowToOverrideSystemScrollSpeed) &&
 202         ReadParam(aMsg, aIter,
 203                   &aResult->mDeltaValuesHorizontalizedForDefaultHandler);
 204     aResult->mScrollType =
 205         static_cast<mozilla::WidgetWheelEvent::ScrollType>(scrollType);
 206     return rv;
 207   }
 208 };
 209
 210 template <>
 211 struct ParamTraits<mozilla::WidgetPointerHelper> {
 212   typedef mozilla::WidgetPointerHelper paramType;
 213
 214   static void Write(Message* aMsg, const paramType& aParam) {
 215     WriteParam(aMsg, aParam.pointerId);
 216     WriteParam(aMsg, aParam.tiltX);
 217     WriteParam(aMsg, aParam.tiltY);
 218     WriteParam(aMsg, aParam.twist);
 219     WriteParam(aMsg, aParam.tangentialPressure);
 220     // We don't serialize convertToPointer since it's temporarily variable and
 221     // should be reset to default.
 222   }
 223
 224   static bool Read(const Message* aMsg, PickleIterator* aIter,
 225                    paramType* aResult) {
 226     bool rv;
 227     rv = ReadParam(aMsg, aIter, &aResult->pointerId) &&
 228          ReadParam(aMsg, aIter, &aResult->tiltX) &&
 229          ReadParam(aMsg, aIter, &aResult->tiltY) &&
 230          ReadParam(aMsg, aIter, &aResult->twist) &&
 231          ReadParam(aMsg, aIter, &aResult->tangentialPressure);
 232     return rv;
 233   }
 234 };
 235
 236 template <>
 237 struct ParamTraits<mozilla::WidgetMouseEvent> {
 238   typedef mozilla::WidgetMouseEvent paramType;
 239
 240   static void Write(Message* aMsg, const paramType& aParam) {
 241     WriteParam(aMsg, static_cast<const mozilla::WidgetMouseEventBase&>(aParam));
 242     WriteParam(aMsg, static_cast<const mozilla::WidgetPointerHelper&>(aParam));
 243     WriteParam(aMsg, aParam.mIgnoreRootScrollFrame);
 244     WriteParam(aMsg, static_cast<paramType::ReasonType>(aParam.mReason));
 245     WriteParam(aMsg, static_cast<paramType::ContextMenuTriggerType>(
 246                          aParam.mContextMenuTrigger));
 247     WriteParam(aMsg, static_cast<paramType::ExitFromType>(aParam.mExitFrom));
 248     WriteParam(aMsg, aParam.mClickCount);
 249   }
 250
 251   static bool Read(const Message* aMsg, PickleIterator* aIter,
 252                    paramType* aResult) {
 253     bool rv;
 254     paramType::ReasonType reason = 0;
 255     paramType::ContextMenuTriggerType contextMenuTrigger = 0;
 256     paramType::ExitFromType exitFrom = 0;
 257     rv = ReadParam(aMsg, aIter,
 258                    static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 259          ReadParam(aMsg, aIter,
 260                    static_cast<mozilla::WidgetPointerHelper*>(aResult)) &&
 261          ReadParam(aMsg, aIter, &aResult->mIgnoreRootScrollFrame) &&
 262          ReadParam(aMsg, aIter, &reason) &&
 263          ReadParam(aMsg, aIter, &contextMenuTrigger) &&
 264          ReadParam(aMsg, aIter, &exitFrom) &&
 265          ReadParam(aMsg, aIter, &aResult->mClickCount);
 266     aResult->mReason = static_cast<paramType::Reason>(reason);
 267     aResult->mContextMenuTrigger =
 268         static_cast<paramType::ContextMenuTrigger>(contextMenuTrigger);
 269     aResult->mExitFrom = static_cast<paramType::ExitFrom>(exitFrom);
 270     return rv;
 271   }
 272 };
 273
 274 template <>
 275 struct ParamTraits<mozilla::WidgetDragEvent> {
 276   typedef mozilla::WidgetDragEvent paramType;
 277
 278   static void Write(Message* aMsg, const paramType& aParam) {
 279     WriteParam(aMsg, static_cast<const mozilla::WidgetMouseEvent&>(aParam));
 280     WriteParam(aMsg, aParam.mUserCancelled);
 281     WriteParam(aMsg, aParam.mDefaultPreventedOnContent);
 282   }
 283
 284   static bool Read(const Message* aMsg, PickleIterator* aIter,
 285                    paramType* aResult) {
 286     bool rv = ReadParam(aMsg, aIter,
 287                         static_cast<mozilla::WidgetMouseEvent*>(aResult)) &&
 288               ReadParam(aMsg, aIter, &aResult->mUserCancelled) &&
 289               ReadParam(aMsg, aIter, &aResult->mDefaultPreventedOnContent);
 290     return rv;
 291   }
 292 };
 293
 294 template <>
 295 struct ParamTraits<mozilla::WidgetPointerEvent> {
 296   typedef mozilla::WidgetPointerEvent paramType;
 297
 298   static void Write(Message* aMsg, const paramType& aParam) {
 299     WriteParam(aMsg, static_cast<const mozilla::WidgetMouseEvent&>(aParam));
 300     WriteParam(aMsg, aParam.mWidth);
 301     WriteParam(aMsg, aParam.mHeight);
 302     WriteParam(aMsg, aParam.mIsPrimary);
 303   }
 304
 305   static bool Read(const Message* aMsg, PickleIterator* aIter,
 306                    paramType* aResult) {
 307     bool rv = ReadParam(aMsg, aIter,
 308                         static_cast<mozilla::WidgetMouseEvent*>(aResult)) &&
 309               ReadParam(aMsg, aIter, &aResult->mWidth) &&
 310               ReadParam(aMsg, aIter, &aResult->mHeight) &&
 311               ReadParam(aMsg, aIter, &aResult->mIsPrimary);
 312     return rv;
 313   }
 314 };
 315
 316 template <>
 317 struct ParamTraits<mozilla::WidgetTouchEvent> {
 318   typedef mozilla::WidgetTouchEvent paramType;
 319
 320   static void Write(Message* aMsg, const paramType& aParam) {
 321     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 322     // Sigh, Touch bites us again!  We want to be able to do
 323     //   WriteParam(aMsg, aParam.mTouches);
 324     const paramType::TouchArray& touches = aParam.mTouches;
 325     WriteParam(aMsg, touches.Length());
 326     for (uint32_t i = 0; i < touches.Length(); ++i) {
 327       mozilla::dom::Touch* touch = touches[i];
 328       WriteParam(aMsg, touch->mIdentifier);
 329       WriteParam(aMsg, touch->mRefPoint);
 330       WriteParam(aMsg, touch->mRadius);
 331       WriteParam(aMsg, touch->mRotationAngle);
 332       WriteParam(aMsg, touch->mForce);
 333     }
 334   }
 335
 336   static bool Read(const Message* aMsg, PickleIterator* aIter,
 337                    paramType* aResult) {
 338     paramType::TouchArray::size_type numTouches;
 339     if (!ReadParam(aMsg, aIter,
 340                    static_cast<mozilla::WidgetInputEvent*>(aResult)) ||
 341         !ReadParam(aMsg, aIter, &numTouches)) {
 342       return false;
 343     }
 344     for (uint32_t i = 0; i < numTouches; ++i) {
 345       int32_t identifier;
 346       mozilla::LayoutDeviceIntPoint refPoint;
 347       mozilla::LayoutDeviceIntPoint radius;
 348       float rotationAngle;
 349       float force;
 350       if (!ReadParam(aMsg, aIter, &identifier) ||
 351           !ReadParam(aMsg, aIter, &refPoint) ||
 352           !ReadParam(aMsg, aIter, &radius) ||
 353           !ReadParam(aMsg, aIter, &rotationAngle) ||
 354           !ReadParam(aMsg, aIter, &force)) {
 355         return false;
 356       }
 357       aResult->mTouches.AppendElement(new mozilla::dom::Touch(
 358           identifier, refPoint, radius, rotationAngle, force));
 359     }
 360     return true;
 361   }
 362 };
 363
 364 template <>
 365 struct ParamTraits<mozilla::AlternativeCharCode> {
 366   typedef mozilla::AlternativeCharCode paramType;
 367
 368   static void Write(Message* aMsg, const paramType& aParam) {
 369     WriteParam(aMsg, aParam.mUnshiftedCharCode);
 370     WriteParam(aMsg, aParam.mShiftedCharCode);
 371   }
 372
 373   static bool Read(const Message* aMsg, PickleIterator* aIter,
 374                    paramType* aResult) {
 375     return ReadParam(aMsg, aIter, &aResult->mUnshiftedCharCode) &&
 376            ReadParam(aMsg, aIter, &aResult->mShiftedCharCode);
 377   }
 378 };
 379
 380 template <>
 381 struct ParamTraits<mozilla::ShortcutKeyCandidate> {
 382   typedef mozilla::ShortcutKeyCandidate paramType;
 383
 384   static void Write(Message* aMsg, const paramType& aParam) {
 385     WriteParam(aMsg, aParam.mCharCode);
 386     WriteParam(aMsg, aParam.mIgnoreShift);
 387   }
 388
 389   static bool Read(const Message* aMsg, PickleIterator* aIter,
 390                    paramType* aResult) {
 391     return ReadParam(aMsg, aIter, &aResult->mCharCode) &&
 392            ReadParam(aMsg, aIter, &aResult->mIgnoreShift);
 393   }
 394 };
 395
 396 template <>
 397 struct ParamTraits<mozilla::WidgetKeyboardEvent> {
 398   typedef mozilla::WidgetKeyboardEvent paramType;
 399
 400   static void Write(Message* aMsg, const paramType& aParam) {
 401     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 402     WriteParam(aMsg,
 403                static_cast<mozilla::KeyNameIndexType>(aParam.mKeyNameIndex));
 404     WriteParam(aMsg,
 405                static_cast<mozilla::CodeNameIndexType>(aParam.mCodeNameIndex));
 406     WriteParam(aMsg, aParam.mKeyValue);
 407     WriteParam(aMsg, aParam.mCodeValue);
 408     WriteParam(aMsg, aParam.mKeyCode);
 409     WriteParam(aMsg, aParam.mCharCode);
 410     WriteParam(aMsg, aParam.mPseudoCharCode);
 411     WriteParam(aMsg, aParam.mAlternativeCharCodes);
 412     WriteParam(aMsg, aParam.mIsRepeat);
 413     WriteParam(aMsg, aParam.mLocation);
 414     WriteParam(aMsg, aParam.mUniqueId);
 415     WriteParam(aMsg, aParam.mIsSynthesizedByTIP);
 416     WriteParam(aMsg, aParam.mMaybeSkippableInRemoteProcess);
 417 #ifdef XP_MACOSX
 418     WriteParam(aMsg, aParam.mNativeKeyCode);
 419     WriteParam(aMsg, aParam.mNativeModifierFlags);
 420     WriteParam(aMsg, aParam.mNativeCharacters);
 421     WriteParam(aMsg, aParam.mNativeCharactersIgnoringModifiers);
 422     WriteParam(aMsg, aParam.mPluginTextEventString);
 423 #endif
 424
 425     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 426     // that cannot be copied across process boundaries.
 427
 428     WriteParam(aMsg, aParam.mEditCommandsForSingleLineEditor);
 429     WriteParam(aMsg, aParam.mEditCommandsForMultiLineEditor);
 430     WriteParam(aMsg, aParam.mEditCommandsForRichTextEditor);
 431     WriteParam(aMsg, aParam.mEditCommandsForSingleLineEditorInitialized);
 432     WriteParam(aMsg, aParam.mEditCommandsForMultiLineEditorInitialized);
 433     WriteParam(aMsg, aParam.mEditCommandsForRichTextEditorInitialized);
 434   }
 435
 436   static bool Read(const Message* aMsg, PickleIterator* aIter,
 437                    paramType* aResult) {
 438     mozilla::KeyNameIndexType keyNameIndex = 0;
 439     mozilla::CodeNameIndexType codeNameIndex = 0;
 440     if (ReadParam(aMsg, aIter,
 441                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 442         ReadParam(aMsg, aIter, &keyNameIndex) &&
 443         ReadParam(aMsg, aIter, &codeNameIndex) &&
 444         ReadParam(aMsg, aIter, &aResult->mKeyValue) &&
 445         ReadParam(aMsg, aIter, &aResult->mCodeValue) &&
 446         ReadParam(aMsg, aIter, &aResult->mKeyCode) &&
 447         ReadParam(aMsg, aIter, &aResult->mCharCode) &&
 448         ReadParam(aMsg, aIter, &aResult->mPseudoCharCode) &&
 449         ReadParam(aMsg, aIter, &aResult->mAlternativeCharCodes) &&
 450         ReadParam(aMsg, aIter, &aResult->mIsRepeat) &&
 451         ReadParam(aMsg, aIter, &aResult->mLocation) &&
 452         ReadParam(aMsg, aIter, &aResult->mUniqueId) &&
 453         ReadParam(aMsg, aIter, &aResult->mIsSynthesizedByTIP) &&
 454         ReadParam(aMsg, aIter, &aResult->mMaybeSkippableInRemoteProcess) &&
 455 #ifdef XP_MACOSX
 456         ReadParam(aMsg, aIter, &aResult->mNativeKeyCode) &&
 457         ReadParam(aMsg, aIter, &aResult->mNativeModifierFlags) &&
 458         ReadParam(aMsg, aIter, &aResult->mNativeCharacters) &&
 459         ReadParam(aMsg, aIter, &aResult->mNativeCharactersIgnoringModifiers) &&
 460         ReadParam(aMsg, aIter, &aResult->mPluginTextEventString) &&
 461 #endif
 462         ReadParam(aMsg, aIter, &aResult->mEditCommandsForSingleLineEditor) &&
 463         ReadParam(aMsg, aIter, &aResult->mEditCommandsForMultiLineEditor) &&
 464         ReadParam(aMsg, aIter, &aResult->mEditCommandsForRichTextEditor) &&
 465         ReadParam(aMsg, aIter,
 466                   &aResult->mEditCommandsForSingleLineEditorInitialized) &&
 467         ReadParam(aMsg, aIter,
 468                   &aResult->mEditCommandsForMultiLineEditorInitialized) &&
 469         ReadParam(aMsg, aIter,
 470                   &aResult->mEditCommandsForRichTextEditorInitialized)) {
 471       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 472       aResult->mCodeNameIndex =
 473           static_cast<mozilla::CodeNameIndex>(codeNameIndex);
 474       aResult->mNativeKeyEvent = nullptr;
 475       return true;
 476     }
 477     return false;
 478   }
 479 };
 480
 481 template <>
 482 struct ParamTraits<mozilla::TextRangeStyle> {
 483   typedef mozilla::TextRangeStyle paramType;
 484
 485   static void Write(Message* aMsg, const paramType& aParam) {
 486     WriteParam(aMsg, aParam.mDefinedStyles);
 487     WriteParam(aMsg, static_cast<mozilla::TextRangeStyle::LineStyleType>(
 488                          aParam.mLineStyle));
 489     WriteParam(aMsg, aParam.mIsBoldLine);
 490     WriteParam(aMsg, aParam.mForegroundColor);
 491     WriteParam(aMsg, aParam.mBackgroundColor);
 492     WriteParam(aMsg, aParam.mUnderlineColor);
 493   }
 494
 495   static bool Read(const Message* aMsg, PickleIterator* aIter,
 496                    paramType* aResult) {
 497     mozilla::TextRangeStyle::LineStyleType lineStyle;
 498     if (!ReadParam(aMsg, aIter, &aResult->mDefinedStyles) ||
 499         !ReadParam(aMsg, aIter, &lineStyle) ||
 500         !ReadParam(aMsg, aIter, &aResult->mIsBoldLine) ||
 501         !ReadParam(aMsg, aIter, &aResult->mForegroundColor) ||
 502         !ReadParam(aMsg, aIter, &aResult->mBackgroundColor) ||
 503         !ReadParam(aMsg, aIter, &aResult->mUnderlineColor)) {
 504       return false;
 505     }
 506     aResult->mLineStyle = mozilla::TextRangeStyle::ToLineStyle(lineStyle);
 507     return true;
 508   }
 509 };
 510
 511 template <>
 512 struct ParamTraits<mozilla::TextRange> {
 513   typedef mozilla::TextRange paramType;
 514
 515   static void Write(Message* aMsg, const paramType& aParam) {
 516     WriteParam(aMsg, aParam.mStartOffset);
 517     WriteParam(aMsg, aParam.mEndOffset);
 518     WriteParam(aMsg, mozilla::ToRawTextRangeType(aParam.mRangeType));
 519     WriteParam(aMsg, aParam.mRangeStyle);
 520   }
 521
 522   static bool Read(const Message* aMsg, PickleIterator* aIter,
 523                    paramType* aResult) {
 524     mozilla::RawTextRangeType rawTextRangeType;
 525     if (ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 526         ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 527         ReadParam(aMsg, aIter, &rawTextRangeType) &&
 528         ReadParam(aMsg, aIter, &aResult->mRangeStyle)) {
 529       aResult->mRangeType = mozilla::ToTextRangeType(rawTextRangeType);
 530       return true;
 531     }
 532     return false;
 533   }
 534 };
 535
 536 template <>
 537 struct ParamTraits<mozilla::TextRangeArray> {
 538   typedef mozilla::TextRangeArray paramType;
 539
 540   static void Write(Message* aMsg, const paramType& aParam) {
 541     WriteParam(aMsg, aParam.Length());
 542     for (uint32_t index = 0; index < aParam.Length(); index++) {
 543       WriteParam(aMsg, aParam[index]);
 544     }
 545   }
 546
 547   static bool Read(const Message* aMsg, PickleIterator* aIter,
 548                    paramType* aResult) {
 549     paramType::size_type length;
 550     if (!ReadParam(aMsg, aIter, &length)) {
 551       return false;
 552     }
 553     for (uint32_t index = 0; index < length; index++) {
 554       mozilla::TextRange textRange;
 555       if (!ReadParam(aMsg, aIter, &textRange)) {
 556         aResult->Clear();
 557         return false;
 558       }
 559       aResult->AppendElement(textRange);
 560     }
 561     return true;
 562   }
 563 };
 564
 565 template <>
 566 struct ParamTraits<mozilla::WidgetCompositionEvent> {
 567   typedef mozilla::WidgetCompositionEvent paramType;
 568
 569   static void Write(Message* aMsg, const paramType& aParam) {
 570     WriteParam(aMsg, static_cast<const mozilla::WidgetGUIEvent&>(aParam));
 571     WriteParam(aMsg, aParam.mData);
 572     WriteParam(aMsg, aParam.mNativeIMEContext);
 573     bool hasRanges = !!aParam.mRanges;
 574     WriteParam(aMsg, hasRanges);
 575     if (hasRanges) {
 576       WriteParam(aMsg, *aParam.mRanges.get());
 577     }
 578   }
 579
 580   static bool Read(const Message* aMsg, PickleIterator* aIter,
 581                    paramType* aResult) {
 582     bool hasRanges;
 583     if (!ReadParam(aMsg, aIter,
 584                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 585         !ReadParam(aMsg, aIter, &aResult->mData) ||
 586         !ReadParam(aMsg, aIter, &aResult->mNativeIMEContext) ||
 587         !ReadParam(aMsg, aIter, &hasRanges)) {
 588       return false;
 589     }
 590
 591     if (!hasRanges) {
 592       aResult->mRanges = nullptr;
 593     } else {
 594       aResult->mRanges = new mozilla::TextRangeArray();
 595       if (!ReadParam(aMsg, aIter, aResult->mRanges.get())) {
 596         return false;
 597       }
 598     }
 599     return true;
 600   }
 601 };
 602
 603 template <>
 604 struct ParamTraits<mozilla::FontRange> {
 605   typedef mozilla::FontRange paramType;
 606
 607   static void Write(Message* aMsg, const paramType& aParam) {
 608     WriteParam(aMsg, aParam.mStartOffset);
 609     WriteParam(aMsg, aParam.mFontName);
 610     WriteParam(aMsg, aParam.mFontSize);
 611   }
 612
 613   static bool Read(const Message* aMsg, PickleIterator* aIter,
 614                    paramType* aResult) {
 615     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 616            ReadParam(aMsg, aIter, &aResult->mFontName) &&
 617            ReadParam(aMsg, aIter, &aResult->mFontSize);
 618   }
 619 };
 620
 621 template <>
 622 struct ParamTraits<mozilla::WidgetQueryContentEvent::Input> {
 623   typedef mozilla::WidgetQueryContentEvent::Input paramType;
 624   typedef mozilla::WidgetQueryContentEvent event;
 625
 626   static void Write(Message* aMsg, const paramType& aParam) {
 627     WriteParam(aMsg, aParam.mOffset);
 628     WriteParam(aMsg, aParam.mLength);
 629     WriteParam(aMsg, mozilla::ToRawSelectionType(aParam.mSelectionType));
 630   }
 631
 632   static bool Read(const Message* aMsg, PickleIterator* aIter,
 633                    paramType* aResult) {
 634     mozilla::RawSelectionType rawSelectionType = 0;
 635     bool ok = ReadParam(aMsg, aIter, &aResult->mOffset) &&
 636               ReadParam(aMsg, aIter, &aResult->mLength) &&
 637               ReadParam(aMsg, aIter, &rawSelectionType);
 638     aResult->mSelectionType = mozilla::ToSelectionType(rawSelectionType);
 639     return ok;
 640   }
 641 };
 642
 643 template <>
 644 struct ParamTraits<mozilla::WidgetQueryContentEvent> {
 645   typedef mozilla::WidgetQueryContentEvent paramType;
 646
 647   static void Write(Message* aMsg, const paramType& aParam) {
 648     WriteParam(aMsg, static_cast<const mozilla::WidgetGUIEvent&>(aParam));
 649     WriteParam(aMsg, aParam.mSucceeded);
 650     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 651     WriteParam(aMsg, aParam.mWithFontRanges);
 652     WriteParam(aMsg, aParam.mInput);
 653     WriteParam(aMsg, aParam.mReply.mOffset);
 654     WriteParam(aMsg, aParam.mReply.mTentativeCaretOffset);
 655     WriteParam(aMsg, aParam.mReply.mString);
 656     WriteParam(aMsg, aParam.mReply.mRect);
 657     WriteParam(aMsg, aParam.mReply.mReversed);
 658     WriteParam(aMsg, aParam.mReply.mHasSelection);
 659     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 660     WriteParam(aMsg, aParam.mReply.mFontRanges);
 661   }
 662
 663   static bool Read(const Message* aMsg, PickleIterator* aIter,
 664                    paramType* aResult) {
 665     return ReadParam(aMsg, aIter,
 666                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 667            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 668            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak) &&
 669            ReadParam(aMsg, aIter, &aResult->mWithFontRanges) &&
 670            ReadParam(aMsg, aIter, &aResult->mInput) &&
 671            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 672            ReadParam(aMsg, aIter, &aResult->mReply.mTentativeCaretOffset) &&
 673            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 674            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 675            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 676            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 677            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit) &&
 678            ReadParam(aMsg, aIter, &aResult->mReply.mFontRanges);
 679   }
 680 };
 681
 682 template <>
 683 struct ParamTraits<mozilla::WidgetSelectionEvent> {
 684   typedef mozilla::WidgetSelectionEvent paramType;
 685
 686   static void Write(Message* aMsg, const paramType& aParam) {
 687     WriteParam(aMsg, static_cast<const mozilla::WidgetGUIEvent&>(aParam));
 688     WriteParam(aMsg, aParam.mOffset);
 689     WriteParam(aMsg, aParam.mLength);
 690     WriteParam(aMsg, aParam.mReversed);
 691     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 692     WriteParam(aMsg, aParam.mSucceeded);
 693     WriteParam(aMsg, aParam.mUseNativeLineBreak);
 694   }
 695
 696   static bool Read(const Message* aMsg, PickleIterator* aIter,
 697                    paramType* aResult) {
 698     return ReadParam(aMsg, aIter,
 699                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 700            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 701            ReadParam(aMsg, aIter, &aResult->mLength) &&
 702            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 703            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 704            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 705            ReadParam(aMsg, aIter, &aResult->mUseNativeLineBreak);
 706   }
 707 };
 708
 709 template <>
 710 struct ParamTraits<mozilla::widget::IMENotificationRequests> {
 711   typedef mozilla::widget::IMENotificationRequests paramType;
 712
 713   static void Write(Message* aMsg, const paramType& aParam) {
 714     WriteParam(aMsg, aParam.mWantUpdates);
 715   }
 716
 717   static bool Read(const Message* aMsg, PickleIterator* aIter,
 718                    paramType* aResult) {
 719     return ReadParam(aMsg, aIter, &aResult->mWantUpdates);
 720   }
 721 };
 722
 723 template <>
 724 struct ParamTraits<mozilla::widget::NativeIMEContext> {
 725   typedef mozilla::widget::NativeIMEContext paramType;
 726
 727   static void Write(Message* aMsg, const paramType& aParam) {
 728     WriteParam(aMsg, aParam.mRawNativeIMEContext);
 729     WriteParam(aMsg, aParam.mOriginProcessID);
 730   }
 731
 732   static bool Read(const Message* aMsg, PickleIterator* aIter,
 733                    paramType* aResult) {
 734     return ReadParam(aMsg, aIter, &aResult->mRawNativeIMEContext) &&
 735            ReadParam(aMsg, aIter, &aResult->mOriginProcessID);
 736   }
 737 };
 738
 739 template <>
 740 struct ParamTraits<mozilla::widget::IMENotification::Point> {
 741   typedef mozilla::widget::IMENotification::Point paramType;
 742
 743   static void Write(Message* aMsg, const paramType& aParam) {
 744     WriteParam(aMsg, aParam.mX);
 745     WriteParam(aMsg, aParam.mY);
 746   }
 747
 748   static bool Read(const Message* aMsg, PickleIterator* aIter,
 749                    paramType* aResult) {
 750     return ReadParam(aMsg, aIter, &aResult->mX) &&
 751            ReadParam(aMsg, aIter, &aResult->mY);
 752   }
 753 };
 754
 755 template <>
 756 struct ParamTraits<mozilla::widget::IMENotification::Rect> {
 757   typedef mozilla::widget::IMENotification::Rect paramType;
 758
 759   static void Write(Message* aMsg, const paramType& aParam) {
 760     WriteParam(aMsg, aParam.mX);
 761     WriteParam(aMsg, aParam.mY);
 762     WriteParam(aMsg, aParam.mWidth);
 763     WriteParam(aMsg, aParam.mHeight);
 764   }
 765
 766   static bool Read(const Message* aMsg, PickleIterator* aIter,
 767                    paramType* aResult) {
 768     return ReadParam(aMsg, aIter, &aResult->mX) &&
 769            ReadParam(aMsg, aIter, &aResult->mY) &&
 770            ReadParam(aMsg, aIter, &aResult->mWidth) &&
 771            ReadParam(aMsg, aIter, &aResult->mHeight);
 772   }
 773 };
 774
 775 template <>
 776 struct ParamTraits<mozilla::widget::IMENotification::SelectionChangeDataBase> {
 777   typedef mozilla::widget::IMENotification::SelectionChangeDataBase paramType;
 778
 779   static void Write(Message* aMsg, const paramType& aParam) {
 780     MOZ_RELEASE_ASSERT(aParam.mString);
 781     WriteParam(aMsg, aParam.mOffset);
 782     WriteParam(aMsg, *aParam.mString);
 783     WriteParam(aMsg, aParam.mWritingMode);
 784     WriteParam(aMsg, aParam.mReversed);
 785     WriteParam(aMsg, aParam.mCausedByComposition);
 786     WriteParam(aMsg, aParam.mCausedBySelectionEvent);
 787     WriteParam(aMsg, aParam.mOccurredDuringComposition);
 788   }
 789
 790   static bool Read(const Message* aMsg, PickleIterator* aIter,
 791                    paramType* aResult) {
 792     aResult->mString = new nsString();
 793     return ReadParam(aMsg, aIter, &aResult->mOffset) &&
 794            ReadParam(aMsg, aIter, aResult->mString) &&
 795            ReadParam(aMsg, aIter, &aResult->mWritingMode) &&
 796            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 797            ReadParam(aMsg, aIter, &aResult->mCausedByComposition) &&
 798            ReadParam(aMsg, aIter, &aResult->mCausedBySelectionEvent) &&
 799            ReadParam(aMsg, aIter, &aResult->mOccurredDuringComposition);
 800   }
 801 };
 802
 803 template <>
 804 struct ParamTraits<mozilla::widget::IMENotification::TextChangeDataBase> {
 805   typedef mozilla::widget::IMENotification::TextChangeDataBase paramType;
 806
 807   static void Write(Message* aMsg, const paramType& aParam) {
 808     WriteParam(aMsg, aParam.mStartOffset);
 809     WriteParam(aMsg, aParam.mRemovedEndOffset);
 810     WriteParam(aMsg, aParam.mAddedEndOffset);
 811     WriteParam(aMsg, aParam.mCausedOnlyByComposition);
 812     WriteParam(aMsg, aParam.mIncludingChangesDuringComposition);
 813     WriteParam(aMsg, aParam.mIncludingChangesWithoutComposition);
 814   }
 815
 816   static bool Read(const Message* aMsg, PickleIterator* aIter,
 817                    paramType* aResult) {
 818     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 819            ReadParam(aMsg, aIter, &aResult->mRemovedEndOffset) &&
 820            ReadParam(aMsg, aIter, &aResult->mAddedEndOffset) &&
 821            ReadParam(aMsg, aIter, &aResult->mCausedOnlyByComposition) &&
 822            ReadParam(aMsg, aIter,
 823                      &aResult->mIncludingChangesDuringComposition) &&
 824            ReadParam(aMsg, aIter,
 825                      &aResult->mIncludingChangesWithoutComposition);
 826   }
 827 };
 828
 829 template <>
 830 struct ParamTraits<mozilla::widget::IMENotification::MouseButtonEventData> {
 831   typedef mozilla::widget::IMENotification::MouseButtonEventData paramType;
 832
 833   static void Write(Message* aMsg, const paramType& aParam) {
 834     WriteParam(aMsg, aParam.mEventMessage);
 835     WriteParam(aMsg, aParam.mOffset);
 836     WriteParam(aMsg, aParam.mCursorPos);
 837     WriteParam(aMsg, aParam.mCharRect);
 838     WriteParam(aMsg, aParam.mButton);
 839     WriteParam(aMsg, aParam.mButtons);
 840     WriteParam(aMsg, aParam.mModifiers);
 841   }
 842
 843   static bool Read(const Message* aMsg, PickleIterator* aIter,
 844                    paramType* aResult) {
 845     return ReadParam(aMsg, aIter, &aResult->mEventMessage) &&
 846            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 847            ReadParam(aMsg, aIter, &aResult->mCursorPos) &&
 848            ReadParam(aMsg, aIter, &aResult->mCharRect) &&
 849            ReadParam(aMsg, aIter, &aResult->mButton) &&
 850            ReadParam(aMsg, aIter, &aResult->mButtons) &&
 851            ReadParam(aMsg, aIter, &aResult->mModifiers);
 852   }
 853 };
 854
 855 template <>
 856 struct ParamTraits<mozilla::widget::IMENotification> {
 857   typedef mozilla::widget::IMENotification paramType;
 858
 859   static void Write(Message* aMsg, const paramType& aParam) {
 860     WriteParam(aMsg,
 861                static_cast<mozilla::widget::IMEMessageType>(aParam.mMessage));
 862     switch (aParam.mMessage) {
 863       case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE:
 864         WriteParam(aMsg, aParam.mSelectionChangeData);
 865         return;
 866       case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE:
 867         WriteParam(aMsg, aParam.mTextChangeData);
 868         return;
 869       case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
 870         WriteParam(aMsg, aParam.mMouseButtonEventData);
 871         return;
 872       default:
 873         return;
 874     }
 875   }
 876
 877   static bool Read(const Message* aMsg, PickleIterator* aIter,
 878                    paramType* aResult) {
 879     mozilla::widget::IMEMessageType IMEMessage = 0;
 880     if (!ReadParam(aMsg, aIter, &IMEMessage)) {
 881       return false;
 882     }
 883     aResult->mMessage = static_cast<mozilla::widget::IMEMessage>(IMEMessage);
 884     switch (aResult->mMessage) {
 885       case mozilla::widget::NOTIFY_IME_OF_SELECTION_CHANGE:
 886         return ReadParam(aMsg, aIter, &aResult->mSelectionChangeData);
 887       case mozilla::widget::NOTIFY_IME_OF_TEXT_CHANGE:
 888         return ReadParam(aMsg, aIter, &aResult->mTextChangeData);
 889       case mozilla::widget::NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
 890         return ReadParam(aMsg, aIter, &aResult->mMouseButtonEventData);
 891       default:
 892         return true;
 893     }
 894   }
 895 };
 896
 897 template <>
 898 struct ParamTraits<mozilla::widget::IMEState::Enabled>
 899     : ContiguousEnumSerializer<mozilla::widget::IMEState::Enabled,
 900                                mozilla::widget::IMEState::Enabled::DISABLED,
 901                                mozilla::widget::IMEState::Enabled::UNKNOWN> {};
 902
 903 template <>
 904 struct ParamTraits<mozilla::widget::IMEState::Open>
 905     : ContiguousEnumSerializerInclusive<
 906           mozilla::widget::IMEState::Open,
 907           mozilla::widget::IMEState::Open::OPEN_STATE_NOT_SUPPORTED,
 908           mozilla::widget::IMEState::Open::CLOSED> {};
 909
 910 template <>
 911 struct ParamTraits<mozilla::widget::IMEState> {
 912   typedef mozilla::widget::IMEState paramType;
 913
 914   static void Write(Message* aMsg, const paramType& aParam) {
 915     WriteParam(aMsg, aParam.mEnabled);
 916     WriteParam(aMsg, aParam.mOpen);
 917   }
 918
 919   static bool Read(const Message* aMsg, PickleIterator* aIter,
 920                    paramType* aResult) {
 921     return ReadParam(aMsg, aIter, &aResult->mEnabled) &&
 922            ReadParam(aMsg, aIter, &aResult->mOpen);
 923   }
 924 };
 925
 926 template <>
 927 struct ParamTraits<mozilla::widget::InputContext::Origin>
 928     : ContiguousEnumSerializerInclusive<
 929           mozilla::widget::InputContext::Origin,
 930           mozilla::widget::InputContext::Origin::ORIGIN_MAIN,
 931           mozilla::widget::InputContext::Origin::ORIGIN_CONTENT> {};
 932
 933 template <>
 934 struct ParamTraits<mozilla::widget::InputContext> {
 935   typedef mozilla::widget::InputContext paramType;
 936
 937   static void Write(Message* aMsg, const paramType& aParam) {
 938     WriteParam(aMsg, aParam.mIMEState);
 939     WriteParam(aMsg, aParam.mHTMLInputType);
 940     WriteParam(aMsg, aParam.mHTMLInputInputmode);
 941     WriteParam(aMsg, aParam.mActionHint);
 942     WriteParam(aMsg, aParam.mOrigin);
 943     WriteParam(aMsg, aParam.mMayBeIMEUnaware);
 944     WriteParam(aMsg, aParam.mHasHandledUserInput);
 945     WriteParam(aMsg, aParam.mInPrivateBrowsing);
 946   }
 947
 948   static bool Read(const Message* aMsg, PickleIterator* aIter,
 949                    paramType* aResult) {
 950     return ReadParam(aMsg, aIter, &aResult->mIMEState) &&
 951            ReadParam(aMsg, aIter, &aResult->mHTMLInputType) &&
 952            ReadParam(aMsg, aIter, &aResult->mHTMLInputInputmode) &&
 953            ReadParam(aMsg, aIter, &aResult->mActionHint) &&
 954            ReadParam(aMsg, aIter, &aResult->mOrigin) &&
 955            ReadParam(aMsg, aIter, &aResult->mMayBeIMEUnaware) &&
 956            ReadParam(aMsg, aIter, &aResult->mHasHandledUserInput) &&
 957            ReadParam(aMsg, aIter, &aResult->mInPrivateBrowsing);
 958   }
 959 };
 960
 961 template <>
 962 struct ParamTraits<mozilla::widget::InputContextAction::Cause>
 963     : ContiguousEnumSerializerInclusive<
 964           mozilla::widget::InputContextAction::Cause,
 965           mozilla::widget::InputContextAction::Cause::CAUSE_UNKNOWN,
 966           mozilla::widget::InputContextAction::Cause::
 967               CAUSE_UNKNOWN_DURING_KEYBOARD_INPUT> {};
 968
 969 template <>
 970 struct ParamTraits<mozilla::widget::InputContextAction::FocusChange>
 971     : ContiguousEnumSerializerInclusive<
 972           mozilla::widget::InputContextAction::FocusChange,
 973           mozilla::widget::InputContextAction::FocusChange::FOCUS_NOT_CHANGED,
 974           mozilla::widget::InputContextAction::FocusChange::WIDGET_CREATED> {};
 975
 976 template <>
 977 struct ParamTraits<mozilla::widget::InputContextAction> {
 978   typedef mozilla::widget::InputContextAction paramType;
 979
 980   static void Write(Message* aMsg, const paramType& aParam) {
 981     WriteParam(aMsg, aParam.mCause);
 982     WriteParam(aMsg, aParam.mFocusChange);
 983   }
 984
 985   static bool Read(const Message* aMsg, PickleIterator* aIter,
 986                    paramType* aResult) {
 987     return ReadParam(aMsg, aIter, &aResult->mCause) &&
 988            ReadParam(aMsg, aIter, &aResult->mFocusChange);
 989   }
 990 };
 991
 992 template <>
 993 struct ParamTraits<mozilla::WidgetPluginEvent> {
 994   typedef mozilla::WidgetPluginEvent paramType;
 995
 996   static void Write(Message* aMsg, const paramType& aParam) {
 997     WriteParam(aMsg, static_cast<const mozilla::WidgetGUIEvent&>(aParam));
 998     WriteParam(aMsg, aParam.mRetargetToFocusedDocument);
 999   }
1000
1001   static bool Read(const Message* aMsg, PickleIterator* aIter,
1002                    paramType* aResult) {
1003     return ReadParam(aMsg, aIter,
1004                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
1005            ReadParam(aMsg, aIter, &aResult->mRetargetToFocusedDocument);
1006   }
1007 };
1008
1009 template <>
1010 struct ParamTraits<mozilla::WritingMode> {
1011   typedef mozilla::WritingMode paramType;
1012
1013   static void Write(Message* aMsg, const paramType& aParam) {
1014     WriteParam(aMsg, aParam.mWritingMode.bits);
1015   }
1016
1017   static bool Read(const Message* aMsg, PickleIterator* aIter,
1018                    paramType* aResult) {
1019     return ReadParam(aMsg, aIter, &aResult->mWritingMode.bits);
1020   }
1021 };
1022
1023 template <>
1024 struct ParamTraits<mozilla::ContentCache> {
1025   typedef mozilla::ContentCache paramType;
1026
1027   static void Write(Message* aMsg, const paramType& aParam) {
1028     WriteParam(aMsg, aParam.mCompositionStart);
1029     WriteParam(aMsg, aParam.mText);
1030     WriteParam(aMsg, aParam.mSelection.mAnchor);
1031     WriteParam(aMsg, aParam.mSelection.mFocus);
1032     WriteParam(aMsg, aParam.mSelection.mWritingMode);
1033     WriteParam(aMsg, aParam.mSelection.mAnchorCharRects[0]);
1034     WriteParam(aMsg, aParam.mSelection.mAnchorCharRects[1]);
1035     WriteParam(aMsg, aParam.mSelection.mFocusCharRects[0]);
1036     WriteParam(aMsg, aParam.mSelection.mFocusCharRects[1]);
1037     WriteParam(aMsg, aParam.mSelection.mRect);
1038     WriteParam(aMsg, aParam.mFirstCharRect);
1039     WriteParam(aMsg, aParam.mCaret.mOffset);
1040     WriteParam(aMsg, aParam.mCaret.mRect);
1041     WriteParam(aMsg, aParam.mTextRectArray.mStart);
1042     WriteParam(aMsg, aParam.mTextRectArray.mRects);
1043     WriteParam(aMsg, aParam.mEditorRect);
1044   }
1045
1046   static bool Read(const Message* aMsg, PickleIterator* aIter,
1047                    paramType* aResult) {
1048     return ReadParam(aMsg, aIter, &aResult->mCompositionStart) &&
1049            ReadParam(aMsg, aIter, &aResult->mText) &&
1050            ReadParam(aMsg, aIter, &aResult->mSelection.mAnchor) &&
1051            ReadParam(aMsg, aIter, &aResult->mSelection.mFocus) &&
1052            ReadParam(aMsg, aIter, &aResult->mSelection.mWritingMode) &&
1053            ReadParam(aMsg, aIter, &aResult->mSelection.mAnchorCharRects[0]) &&
1054            ReadParam(aMsg, aIter, &aResult->mSelection.mAnchorCharRects[1]) &&
1055            ReadParam(aMsg, aIter, &aResult->mSelection.mFocusCharRects[0]) &&
1056            ReadParam(aMsg, aIter, &aResult->mSelection.mFocusCharRects[1]) &&
1057            ReadParam(aMsg, aIter, &aResult->mSelection.mRect) &&
1058            ReadParam(aMsg, aIter, &aResult->mFirstCharRect) &&
1059            ReadParam(aMsg, aIter, &aResult->mCaret.mOffset) &&
1060            ReadParam(aMsg, aIter, &aResult->mCaret.mRect) &&
1061            ReadParam(aMsg, aIter, &aResult->mTextRectArray.mStart) &&
1062            ReadParam(aMsg, aIter, &aResult->mTextRectArray.mRects) &&
1063            ReadParam(aMsg, aIter, &aResult->mEditorRect);
1064   }
1065 };
1066
1067 template <>
1068 struct ParamTraits<mozilla::widget::CandidateWindowPosition> {
1069   typedef mozilla::widget::CandidateWindowPosition paramType;
1070
1071   static void Write(Message* aMsg, const paramType& aParam) {
1072     WriteParam(aMsg, aParam.mPoint);
1073     WriteParam(aMsg, aParam.mRect);
1074     WriteParam(aMsg, aParam.mExcludeRect);
1075   }
1076
1077   static bool Read(const Message* aMsg, PickleIterator* aIter,
1078                    paramType* aResult) {
1079     return ReadParam(aMsg, aIter, &aResult->mPoint) &&
1080            ReadParam(aMsg, aIter, &aResult->mRect) &&
1081            ReadParam(aMsg, aIter, &aResult->mExcludeRect);
1082   }
1083 };
1084
1085 // InputData.h
1086
1087 template <>
1088 struct ParamTraits<mozilla::InputType>
1089     : public ContiguousEnumSerializerInclusive<
1090           mozilla::InputType, mozilla::InputType::MULTITOUCH_INPUT,
1091           mozilla::kHighestInputType> {};
1092
1093 template <>
1094 struct ParamTraits<mozilla::InputData> {
1095   typedef mozilla::InputData paramType;
1096
1097   static void Write(Message* aMsg, const paramType& aParam) {
1098     WriteParam(aMsg, aParam.mInputType);
1099     WriteParam(aMsg, aParam.mTime);
1100     WriteParam(aMsg, aParam.mTimeStamp);
1101     WriteParam(aMsg, aParam.modifiers);
1102     WriteParam(aMsg, aParam.mFocusSequenceNumber);
1103     WriteParam(aMsg, aParam.mLayersId);
1104   }
1105
1106   static bool Read(const Message* aMsg, PickleIterator* aIter,
1107                    paramType* aResult) {
1108     return ReadParam(aMsg, aIter, &aResult->mInputType) &&
1109            ReadParam(aMsg, aIter, &aResult->mTime) &&
1110            ReadParam(aMsg, aIter, &aResult->mTimeStamp) &&
1111            ReadParam(aMsg, aIter, &aResult->modifiers) &&
1112            ReadParam(aMsg, aIter, &aResult->mFocusSequenceNumber) &&
1113            ReadParam(aMsg, aIter, &aResult->mLayersId);
1114   }
1115 };
1116
1117 template <>
1118 struct ParamTraits<mozilla::SingleTouchData> {
1119   typedef mozilla::SingleTouchData paramType;
1120
1121   static void Write(Message* aMsg, const paramType& aParam) {
1122     WriteParam(aMsg, aParam.mIdentifier);
1123     WriteParam(aMsg, aParam.mScreenPoint);
1124     WriteParam(aMsg, aParam.mLocalScreenPoint);
1125     WriteParam(aMsg, aParam.mRadius);
1126     WriteParam(aMsg, aParam.mRotationAngle);
1127     WriteParam(aMsg, aParam.mForce);
1128   }
1129
1130   static bool Read(const Message* aMsg, PickleIterator* aIter,
1131                    paramType* aResult) {
1132     return (ReadParam(aMsg, aIter, &aResult->mIdentifier) &&
1133             ReadParam(aMsg, aIter, &aResult->mScreenPoint) &&
1134             ReadParam(aMsg, aIter, &aResult->mLocalScreenPoint) &&
1135             ReadParam(aMsg, aIter, &aResult->mRadius) &&
1136             ReadParam(aMsg, aIter, &aResult->mRotationAngle) &&
1137             ReadParam(aMsg, aIter, &aResult->mForce));
1138   }
1139 };
1140
1141 template <>
1142 struct ParamTraits<mozilla::MultiTouchInput::MultiTouchType>
1143     : public ContiguousEnumSerializerInclusive<
1144           mozilla::MultiTouchInput::MultiTouchType,
1145           mozilla::MultiTouchInput::MultiTouchType::MULTITOUCH_START,
1146           mozilla::MultiTouchInput::sHighestMultiTouchType> {};
1147
1148 template <>
1149 struct ParamTraits<mozilla::MultiTouchInput> {
1150   typedef mozilla::MultiTouchInput paramType;
1151
1152   static void Write(Message* aMsg, const paramType& aParam) {
1153     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1154     WriteParam(aMsg, aParam.mType);
1155     WriteParam(aMsg, aParam.mTouches);
1156     WriteParam(aMsg, aParam.mHandledByAPZ);
1157     WriteParam(aMsg, aParam.mScreenOffset);
1158   }
1159
1160   static bool Read(const Message* aMsg, PickleIterator* aIter,
1161                    paramType* aResult) {
1162     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1163            ReadParam(aMsg, aIter, &aResult->mType) &&
1164            ReadParam(aMsg, aIter, &aResult->mTouches) &&
1165            ReadParam(aMsg, aIter, &aResult->mHandledByAPZ) &&
1166            ReadParam(aMsg, aIter, &aResult->mScreenOffset);
1167   }
1168 };
1169
1170 template <>
1171 struct ParamTraits<mozilla::MouseInput::MouseType>
1172     : public ContiguousEnumSerializerInclusive<
1173           mozilla::MouseInput::MouseType,
1174           mozilla::MouseInput::MouseType::MOUSE_NONE,
1175           mozilla::MouseInput::sHighestMouseType> {};
1176
1177 template <>
1178 struct ParamTraits<mozilla::MouseInput::ButtonType>
1179     : public ContiguousEnumSerializerInclusive<
1180           mozilla::MouseInput::ButtonType,
1181           mozilla::MouseInput::ButtonType::PRIMARY_BUTTON,
1182           mozilla::MouseInput::sHighestButtonType> {};
1183
1184 template <>
1185 struct ParamTraits<mozilla::MouseInput> {
1186   typedef mozilla::MouseInput paramType;
1187
1188   static void Write(Message* aMsg, const paramType& aParam) {
1189     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1190     WriteParam(aMsg, aParam.mButtonType);
1191     WriteParam(aMsg, aParam.mType);
1192     WriteParam(aMsg, aParam.mInputSource);
1193     WriteParam(aMsg, aParam.mButtons);
1194     WriteParam(aMsg, aParam.mOrigin);
1195     WriteParam(aMsg, aParam.mLocalOrigin);
1196     WriteParam(aMsg, aParam.mHandledByAPZ);
1197   }
1198
1199   static bool Read(const Message* aMsg, PickleIterator* aIter,
1200                    paramType* aResult) {
1201     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1202            ReadParam(aMsg, aIter, &aResult->mButtonType) &&
1203            ReadParam(aMsg, aIter, &aResult->mType) &&
1204            ReadParam(aMsg, aIter, &aResult->mInputSource) &&
1205            ReadParam(aMsg, aIter, &aResult->mButtons) &&
1206            ReadParam(aMsg, aIter, &aResult->mOrigin) &&
1207            ReadParam(aMsg, aIter, &aResult->mLocalOrigin) &&
1208            ReadParam(aMsg, aIter, &aResult->mHandledByAPZ);
1209   }
1210 };
1211
1212 template <>
1213 struct ParamTraits<mozilla::PanGestureInput::PanGestureType>
1214     : public ContiguousEnumSerializerInclusive<
1215           mozilla::PanGestureInput::PanGestureType,
1216           mozilla::PanGestureInput::PanGestureType::PANGESTURE_MAYSTART,
1217           mozilla::PanGestureInput::sHighestPanGestureType> {};
1218
1219 template <>
1220 struct ParamTraits<mozilla::PanGestureInput::PanDeltaType>
1221     : public ContiguousEnumSerializerInclusive<
1222           mozilla::PanGestureInput::PanDeltaType,
1223           mozilla::PanGestureInput::PanDeltaType::PANDELTA_PAGE,
1224           mozilla::PanGestureInput::sHighestPanDeltaType> {};
1225
1226 template <>
1227 struct ParamTraits<mozilla::PanGestureInput>
1228     : BitfieldHelper<mozilla::PanGestureInput> {
1229   typedef mozilla::PanGestureInput paramType;
1230
1231   static void Write(Message* aMsg, const paramType& aParam) {
1232     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1233     WriteParam(aMsg, aParam.mType);
1234     WriteParam(aMsg, aParam.mPanStartPoint);
1235     WriteParam(aMsg, aParam.mPanDisplacement);
1236     WriteParam(aMsg, aParam.mLocalPanStartPoint);
1237     WriteParam(aMsg, aParam.mLocalPanDisplacement);
1238     WriteParam(aMsg, aParam.mLineOrPageDeltaX);
1239     WriteParam(aMsg, aParam.mLineOrPageDeltaY);
1240     WriteParam(aMsg, aParam.mUserDeltaMultiplierX);
1241     WriteParam(aMsg, aParam.mUserDeltaMultiplierY);
1242     WriteParam(aMsg, aParam.mDeltaType);
1243     WriteParam(aMsg, aParam.mHandledByAPZ);
1244     WriteParam(aMsg, aParam.mFollowedByMomentum);
1245     WriteParam(
1246         aMsg,
1247         aParam
1248             .mRequiresContentResponseIfCannotScrollHorizontallyInStartDirection);
1249     WriteParam(aMsg, aParam.mOverscrollBehaviorAllowsSwipe);
1250     WriteParam(aMsg, aParam.mSimulateMomentum);
1251   }
1252
1253   static bool Read(const Message* aMsg, PickleIterator* aIter,
1254                    paramType* aResult) {
1255     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1256            ReadParam(aMsg, aIter, &aResult->mType) &&
1257            ReadParam(aMsg, aIter, &aResult->mPanStartPoint) &&
1258            ReadParam(aMsg, aIter, &aResult->mPanDisplacement) &&
1259            ReadParam(aMsg, aIter, &aResult->mLocalPanStartPoint) &&
1260            ReadParam(aMsg, aIter, &aResult->mLocalPanDisplacement) &&
1261            ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaX) &&
1262            ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaY) &&
1263            ReadParam(aMsg, aIter, &aResult->mUserDeltaMultiplierX) &&
1264            ReadParam(aMsg, aIter, &aResult->mUserDeltaMultiplierY) &&
1265            ReadParam(aMsg, aIter, &aResult->mDeltaType) &&
1266            ReadBoolForBitfield(aMsg, aIter, aResult,
1267                                &paramType::SetHandledByAPZ) &&
1268            ReadBoolForBitfield(aMsg, aIter, aResult,
1269                                &paramType::SetFollowedByMomentum) &&
1270            ReadBoolForBitfield(
1271                aMsg, aIter, aResult,
1272                &paramType::
1273                    SetRequiresContentResponseIfCannotScrollHorizontallyInStartDirection) &&
1274            ReadBoolForBitfield(aMsg, aIter, aResult,
1275                                &paramType::SetOverscrollBehaviorAllowsSwipe) &&
1276            ReadBoolForBitfield(aMsg, aIter, aResult,
1277                                &paramType::SetSimulateMomentum);
1278   }
1279 };
1280
1281 template <>
1282 struct ParamTraits<mozilla::PinchGestureInput::PinchGestureType>
1283     : public ContiguousEnumSerializerInclusive<
1284           mozilla::PinchGestureInput::PinchGestureType,
1285           mozilla::PinchGestureInput::PinchGestureType::PINCHGESTURE_START,
1286           mozilla::PinchGestureInput::sHighestPinchGestureType> {};
1287
1288 template <>
1289 struct ParamTraits<mozilla::PinchGestureInput::PinchGestureSource>
1290     : public ContiguousEnumSerializerInclusive<
1291           mozilla::PinchGestureInput::PinchGestureSource,
1292           // Set the min to TOUCH, to ensure UNKNOWN is never sent over IPC
1293           mozilla::PinchGestureInput::PinchGestureSource::TOUCH,
1294           mozilla::PinchGestureInput::sHighestPinchGestureSource> {};
1295
1296 template <>
1297 struct ParamTraits<mozilla::PinchGestureInput> {
1298   typedef mozilla::PinchGestureInput paramType;
1299
1300   static void Write(Message* aMsg, const paramType& aParam) {
1301     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1302     WriteParam(aMsg, aParam.mType);
1303     WriteParam(aMsg, aParam.mSource);
1304     WriteParam(aMsg, aParam.mScreenOffset);
1305     WriteParam(aMsg, aParam.mFocusPoint);
1306     WriteParam(aMsg, aParam.mLocalFocusPoint);
1307     WriteParam(aMsg, aParam.mCurrentSpan);
1308     WriteParam(aMsg, aParam.mPreviousSpan);
1309     WriteParam(aMsg, aParam.mHandledByAPZ);
1310   }
1311
1312   static bool Read(const Message* aMsg, PickleIterator* aIter,
1313                    paramType* aResult) {
1314     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1315            ReadParam(aMsg, aIter, &aResult->mType) &&
1316            ReadParam(aMsg, aIter, &aResult->mSource) &&
1317            ReadParam(aMsg, aIter, &aResult->mScreenOffset) &&
1318            ReadParam(aMsg, aIter, &aResult->mFocusPoint) &&
1319            ReadParam(aMsg, aIter, &aResult->mLocalFocusPoint) &&
1320            ReadParam(aMsg, aIter, &aResult->mCurrentSpan) &&
1321            ReadParam(aMsg, aIter, &aResult->mPreviousSpan) &&
1322            ReadParam(aMsg, aIter, &aResult->mHandledByAPZ);
1323   }
1324 };
1325
1326 template <>
1327 struct ParamTraits<mozilla::TapGestureInput::TapGestureType>
1328     : public ContiguousEnumSerializerInclusive<
1329           mozilla::TapGestureInput::TapGestureType,
1330           mozilla::TapGestureInput::TapGestureType::TAPGESTURE_LONG,
1331           mozilla::TapGestureInput::sHighestTapGestureType> {};
1332
1333 template <>
1334 struct ParamTraits<mozilla::TapGestureInput> {
1335   typedef mozilla::TapGestureInput paramType;
1336
1337   static void Write(Message* aMsg, const paramType& aParam) {
1338     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1339     WriteParam(aMsg, aParam.mType);
1340     WriteParam(aMsg, aParam.mPoint);
1341     WriteParam(aMsg, aParam.mLocalPoint);
1342   }
1343
1344   static bool Read(const Message* aMsg, PickleIterator* aIter,
1345                    paramType* aResult) {
1346     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1347            ReadParam(aMsg, aIter, &aResult->mType) &&
1348            ReadParam(aMsg, aIter, &aResult->mPoint) &&
1349            ReadParam(aMsg, aIter, &aResult->mLocalPoint);
1350   }
1351 };
1352
1353 template <>
1354 struct ParamTraits<mozilla::ScrollWheelInput::ScrollDeltaType>
1355     : public ContiguousEnumSerializerInclusive<
1356           mozilla::ScrollWheelInput::ScrollDeltaType,
1357           mozilla::ScrollWheelInput::ScrollDeltaType::SCROLLDELTA_LINE,
1358           mozilla::ScrollWheelInput::sHighestScrollDeltaType> {};
1359
1360 template <>
1361 struct ParamTraits<mozilla::ScrollWheelInput::ScrollMode>
1362     : public ContiguousEnumSerializerInclusive<
1363           mozilla::ScrollWheelInput::ScrollMode,
1364           mozilla::ScrollWheelInput::ScrollMode::SCROLLMODE_INSTANT,
1365           mozilla::ScrollWheelInput::sHighestScrollMode> {};
1366
1367 template <>
1368 struct ParamTraits<mozilla::WheelDeltaAdjustmentStrategy>
1369     : public ContiguousEnumSerializer<
1370           mozilla::WheelDeltaAdjustmentStrategy,
1371           mozilla::WheelDeltaAdjustmentStrategy(0),
1372           mozilla::WheelDeltaAdjustmentStrategy::eSentinel> {};
1373
1374 template <>
1375 struct ParamTraits<mozilla::layers::APZWheelAction>
1376     : public ContiguousEnumSerializerInclusive<
1377           mozilla::layers::APZWheelAction,
1378           mozilla::layers::APZWheelAction::Scroll,
1379           mozilla::layers::kHighestAPZWheelAction> {};
1380
1381 template <>
1382 struct ParamTraits<mozilla::ScrollWheelInput> {
1383   typedef mozilla::ScrollWheelInput paramType;
1384
1385   static void Write(Message* aMsg, const paramType& aParam) {
1386     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1387     WriteParam(aMsg, aParam.mDeltaType);
1388     WriteParam(aMsg, aParam.mScrollMode);
1389     WriteParam(aMsg, aParam.mOrigin);
1390     WriteParam(aMsg, aParam.mHandledByAPZ);
1391     WriteParam(aMsg, aParam.mDeltaX);
1392     WriteParam(aMsg, aParam.mDeltaY);
1393     WriteParam(aMsg, aParam.mLocalOrigin);
1394     WriteParam(aMsg, aParam.mLineOrPageDeltaX);
1395     WriteParam(aMsg, aParam.mLineOrPageDeltaY);
1396     WriteParam(aMsg, aParam.mScrollSeriesNumber);
1397     WriteParam(aMsg, aParam.mUserDeltaMultiplierX);
1398     WriteParam(aMsg, aParam.mUserDeltaMultiplierY);
1399     WriteParam(aMsg, aParam.mMayHaveMomentum);
1400     WriteParam(aMsg, aParam.mIsMomentum);
1401     WriteParam(aMsg, aParam.mAllowToOverrideSystemScrollSpeed);
1402     WriteParam(aMsg, aParam.mWheelDeltaAdjustmentStrategy);
1403     WriteParam(aMsg, aParam.mAPZAction);
1404   }
1405
1406   static bool Read(const Message* aMsg, PickleIterator* aIter,
1407                    paramType* aResult) {
1408     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1409            ReadParam(aMsg, aIter, &aResult->mDeltaType) &&
1410            ReadParam(aMsg, aIter, &aResult->mScrollMode) &&
1411            ReadParam(aMsg, aIter, &aResult->mOrigin) &&
1412            ReadParam(aMsg, aIter, &aResult->mHandledByAPZ) &&
1413            ReadParam(aMsg, aIter, &aResult->mDeltaX) &&
1414            ReadParam(aMsg, aIter, &aResult->mDeltaY) &&
1415            ReadParam(aMsg, aIter, &aResult->mLocalOrigin) &&
1416            ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaX) &&
1417            ReadParam(aMsg, aIter, &aResult->mLineOrPageDeltaY) &&
1418            ReadParam(aMsg, aIter, &aResult->mScrollSeriesNumber) &&
1419            ReadParam(aMsg, aIter, &aResult->mUserDeltaMultiplierX) &&
1420            ReadParam(aMsg, aIter, &aResult->mUserDeltaMultiplierY) &&
1421            ReadParam(aMsg, aIter, &aResult->mMayHaveMomentum) &&
1422            ReadParam(aMsg, aIter, &aResult->mIsMomentum) &&
1423            ReadParam(aMsg, aIter,
1424                      &aResult->mAllowToOverrideSystemScrollSpeed) &&
1425            ReadParam(aMsg, aIter, &aResult->mWheelDeltaAdjustmentStrategy) &&
1426            ReadParam(aMsg, aIter, &aResult->mAPZAction);
1427   }
1428 };
1429
1430 template <>
1431 struct ParamTraits<mozilla::KeyboardInput::KeyboardEventType>
1432     : public ContiguousEnumSerializer<
1433           mozilla::KeyboardInput::KeyboardEventType,
1434           mozilla::KeyboardInput::KeyboardEventType::KEY_DOWN,
1435           mozilla::KeyboardInput::KeyboardEventType::KEY_SENTINEL> {};
1436
1437 template <>
1438 struct ParamTraits<mozilla::KeyboardInput> {
1439   typedef mozilla::KeyboardInput paramType;
1440
1441   static void Write(Message* aMsg, const paramType& aParam) {
1442     WriteParam(aMsg, static_cast<const mozilla::InputData&>(aParam));
1443     WriteParam(aMsg, aParam.mType);
1444     WriteParam(aMsg, aParam.mKeyCode);
1445     WriteParam(aMsg, aParam.mCharCode);
1446     WriteParam(aMsg, aParam.mShortcutCandidates);
1447     WriteParam(aMsg, aParam.mHandledByAPZ);
1448   }
1449
1450   static bool Read(const Message* aMsg, PickleIterator* aIter,
1451                    paramType* aResult) {
1452     return ReadParam(aMsg, aIter, static_cast<mozilla::InputData*>(aResult)) &&
1453            ReadParam(aMsg, aIter, &aResult->mType) &&
1454            ReadParam(aMsg, aIter, &aResult->mKeyCode) &&
1455            ReadParam(aMsg, aIter, &aResult->mCharCode) &&
1456            ReadParam(aMsg, aIter, &aResult->mShortcutCandidates) &&
1457            ReadParam(aMsg, aIter, &aResult->mHandledByAPZ);
1458   }
1459 };
1460
1461 }  // namespace IPC
1462
1463 #endif  // nsGUIEventIPC_h__