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