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