widget/nsGUIEventIPC.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef nsGUIEventIPC_h__
   7 #define nsGUIEventIPC_h__
   8
   9 #include "ipc/IPCMessageUtils.h"
  10 #include "mozilla/GfxMessageUtils.h"
  11 #include "mozilla/dom/Touch.h"
  12 #include "mozilla/MiscEvents.h"
  13 #include "mozilla/MouseEvents.h"
  14 #include "mozilla/TextEvents.h"
  15 #include "mozilla/TouchEvents.h"
  16
  17 namespace IPC
  18 {
  19
  20 template<>
  21 struct ParamTraits<mozilla::BaseEventFlags>
  22 {
  23   typedef mozilla::BaseEventFlags paramType;
  24
  25   static void Write(Message* aMsg, const paramType& aParam)
  26   {
  27     aMsg->WriteBytes(&aParam, sizeof(aParam));
  28   }
  29
  30   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  31   {
  32     const char* outp;
  33     if (!aMsg->ReadBytes(aIter, &outp, sizeof(*aResult))) {
  34       return false;
  35     }
  36     *aResult = *reinterpret_cast<const paramType*>(outp);
  37     return true;
  38   }
  39 };
  40
  41 template<>
  42 struct ParamTraits<mozilla::WidgetEvent>
  43 {
  44   typedef mozilla::WidgetEvent paramType;
  45
  46   static void Write(Message* aMsg, const paramType& aParam)
  47   {
  48     WriteParam(aMsg, (uint8_t) aParam.eventStructType);
  49     WriteParam(aMsg, aParam.message);
  50     WriteParam(aMsg, aParam.refPoint);
  51     WriteParam(aMsg, aParam.time);
  52     WriteParam(aMsg, aParam.mFlags);
  53   }
  54
  55   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  56   {
  57     uint8_t eventStructType = 0;
  58     bool ret = ReadParam(aMsg, aIter, &eventStructType) &&
  59                ReadParam(aMsg, aIter, &aResult->message) &&
  60                ReadParam(aMsg, aIter, &aResult->refPoint) &&
  61                ReadParam(aMsg, aIter, &aResult->time) &&
  62                ReadParam(aMsg, aIter, &aResult->mFlags);
  63     aResult->eventStructType = static_cast<nsEventStructType>(eventStructType);
  64     return ret;
  65   }
  66 };
  67
  68 template<>
  69 struct ParamTraits<mozilla::WidgetGUIEvent>
  70 {
  71   typedef mozilla::WidgetGUIEvent paramType;
  72
  73   static void Write(Message* aMsg, const paramType& aParam)
  74   {
  75     WriteParam(aMsg, static_cast<mozilla::WidgetEvent>(aParam));
  76   }
  77
  78   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  79   {
  80     return ReadParam(aMsg, aIter, static_cast<mozilla::WidgetEvent*>(aResult));
  81   }
  82 };
  83
  84 template<>
  85 struct ParamTraits<mozilla::WidgetInputEvent>
  86 {
  87   typedef mozilla::WidgetInputEvent paramType;
  88
  89   static void Write(Message* aMsg, const paramType& aParam)
  90   {
  91     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
  92     WriteParam(aMsg, aParam.modifiers);
  93   }
  94
  95   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  96   {
  97     return ReadParam(aMsg, aIter,
  98                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
  99            ReadParam(aMsg, aIter, &aResult->modifiers);
 100   }
 101 };
 102
 103 template<>
 104 struct ParamTraits<mozilla::WidgetMouseEventBase>
 105 {
 106   typedef mozilla::WidgetMouseEventBase paramType;
 107
 108   static void Write(Message* aMsg, const paramType& aParam)
 109   {
 110     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 111     WriteParam(aMsg, aParam.button);
 112     WriteParam(aMsg, aParam.buttons);
 113     WriteParam(aMsg, aParam.pressure);
 114     WriteParam(aMsg, aParam.inputSource);
 115   }
 116
 117   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 118   {
 119     return ReadParam(aMsg, aIter,
 120                      static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 121            ReadParam(aMsg, aIter, &aResult->button) &&
 122            ReadParam(aMsg, aIter, &aResult->buttons) &&
 123            ReadParam(aMsg, aIter, &aResult->pressure) &&
 124            ReadParam(aMsg, aIter, &aResult->inputSource);
 125   }
 126 };
 127
 128 template<>
 129 struct ParamTraits<mozilla::WidgetWheelEvent>
 130 {
 131   typedef mozilla::WidgetWheelEvent paramType;
 132
 133   static void Write(Message* aMsg, const paramType& aParam)
 134   {
 135     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 136     WriteParam(aMsg, aParam.deltaX);
 137     WriteParam(aMsg, aParam.deltaY);
 138     WriteParam(aMsg, aParam.deltaZ);
 139     WriteParam(aMsg, aParam.deltaMode);
 140     WriteParam(aMsg, aParam.customizedByUserPrefs);
 141     WriteParam(aMsg, aParam.isMomentum);
 142     WriteParam(aMsg, aParam.isPixelOnlyDevice);
 143     WriteParam(aMsg, aParam.lineOrPageDeltaX);
 144     WriteParam(aMsg, aParam.lineOrPageDeltaY);
 145     WriteParam(aMsg, static_cast<int32_t>(aParam.scrollType));
 146     WriteParam(aMsg, aParam.overflowDeltaX);
 147     WriteParam(aMsg, aParam.overflowDeltaY);
 148   }
 149
 150   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 151   {
 152     int32_t scrollType = 0;
 153     bool rv =
 154       ReadParam(aMsg, aIter,
 155                 static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 156       ReadParam(aMsg, aIter, &aResult->deltaX) &&
 157       ReadParam(aMsg, aIter, &aResult->deltaY) &&
 158       ReadParam(aMsg, aIter, &aResult->deltaZ) &&
 159       ReadParam(aMsg, aIter, &aResult->deltaMode) &&
 160       ReadParam(aMsg, aIter, &aResult->customizedByUserPrefs) &&
 161       ReadParam(aMsg, aIter, &aResult->isMomentum) &&
 162       ReadParam(aMsg, aIter, &aResult->isPixelOnlyDevice) &&
 163       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaX) &&
 164       ReadParam(aMsg, aIter, &aResult->lineOrPageDeltaY) &&
 165       ReadParam(aMsg, aIter, &scrollType) &&
 166       ReadParam(aMsg, aIter, &aResult->overflowDeltaX) &&
 167       ReadParam(aMsg, aIter, &aResult->overflowDeltaY);
 168     aResult->scrollType =
 169       static_cast<mozilla::WidgetWheelEvent::ScrollType>(scrollType);
 170     return rv;
 171   }
 172 };
 173
 174 template<>
 175 struct ParamTraits<mozilla::WidgetMouseEvent>
 176 {
 177   typedef mozilla::WidgetMouseEvent paramType;
 178
 179   static void Write(Message* aMsg, const paramType& aParam)
 180   {
 181     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEventBase>(aParam));
 182     WriteParam(aMsg, aParam.ignoreRootScrollFrame);
 183     WriteParam(aMsg, (uint8_t) aParam.reason);
 184     WriteParam(aMsg, (uint8_t) aParam.context);
 185     WriteParam(aMsg, (uint8_t) aParam.exit);
 186     WriteParam(aMsg, aParam.clickCount);
 187   }
 188
 189   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 190   {
 191     bool rv;
 192     uint8_t reason = 0, context = 0, exit = 0;
 193     rv = ReadParam(aMsg, aIter,
 194                    static_cast<mozilla::WidgetMouseEventBase*>(aResult)) &&
 195          ReadParam(aMsg, aIter, &aResult->ignoreRootScrollFrame) &&
 196          ReadParam(aMsg, aIter, &reason) &&
 197          ReadParam(aMsg, aIter, &context) &&
 198          ReadParam(aMsg, aIter, &exit) &&
 199          ReadParam(aMsg, aIter, &aResult->clickCount);
 200     aResult->reason =
 201       static_cast<mozilla::WidgetMouseEvent::reasonType>(reason);
 202     aResult->context =
 203       static_cast<mozilla::WidgetMouseEvent::contextType>(context);
 204     aResult->exit = static_cast<mozilla::WidgetMouseEvent::exitType>(exit);
 205     return rv;
 206   }
 207 };
 208
 209 template<>
 210 struct ParamTraits<mozilla::WidgetPointerEvent>
 211 {
 212   typedef mozilla::WidgetPointerEvent paramType;
 213
 214   static void Write(Message* aMsg, const paramType& aParam)
 215   {
 216     WriteParam(aMsg, static_cast<mozilla::WidgetMouseEvent>(aParam));
 217     WriteParam(aMsg, aParam.pointerId);
 218     WriteParam(aMsg, aParam.width);
 219     WriteParam(aMsg, aParam.height);
 220     WriteParam(aMsg, aParam.tiltX);
 221     WriteParam(aMsg, aParam.tiltY);
 222     WriteParam(aMsg, aParam.isPrimary);
 223   }
 224
 225   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 226   {
 227     bool rv =
 228       ReadParam(aMsg, aIter, static_cast<mozilla::WidgetMouseEvent*>(aResult)) &&
 229       ReadParam(aMsg, aIter, &aResult->pointerId) &&
 230       ReadParam(aMsg, aIter, &aResult->width) &&
 231       ReadParam(aMsg, aIter, &aResult->height) &&
 232       ReadParam(aMsg, aIter, &aResult->tiltX) &&
 233       ReadParam(aMsg, aIter, &aResult->tiltY) &&
 234       ReadParam(aMsg, aIter, &aResult->isPrimary);
 235     return rv;
 236   }
 237 };
 238
 239 template<>
 240 struct ParamTraits<mozilla::WidgetTouchEvent>
 241 {
 242   typedef mozilla::WidgetTouchEvent paramType;
 243
 244   static void Write(Message* aMsg, const paramType& aParam)
 245   {
 246     WriteParam(aMsg, static_cast<const mozilla::WidgetInputEvent&>(aParam));
 247     // Sigh, Touch bites us again!  We want to be able to do
 248     //   WriteParam(aMsg, aParam.touches);
 249     const nsTArray< nsRefPtr<mozilla::dom::Touch> >& touches = aParam.touches;
 250     WriteParam(aMsg, touches.Length());
 251     for (uint32_t i = 0; i < touches.Length(); ++i) {
 252       mozilla::dom::Touch* touch = touches[i];
 253       WriteParam(aMsg, touch->mIdentifier);
 254       WriteParam(aMsg, touch->mRefPoint);
 255       WriteParam(aMsg, touch->mRadius);
 256       WriteParam(aMsg, touch->mRotationAngle);
 257       WriteParam(aMsg, touch->mForce);
 258     }
 259   }
 260
 261   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 262   {
 263     uint32_t numTouches;
 264     if (!ReadParam(aMsg, aIter,
 265                    static_cast<mozilla::WidgetInputEvent*>(aResult)) ||
 266         !ReadParam(aMsg, aIter, &numTouches)) {
 267       return false;
 268     }
 269     for (uint32_t i = 0; i < numTouches; ++i) {
 270         int32_t identifier;
 271         mozilla::LayoutDeviceIntPoint refPoint;
 272         nsIntPoint radius;
 273         float rotationAngle;
 274         float force;
 275         if (!ReadParam(aMsg, aIter, &identifier) ||
 276             !ReadParam(aMsg, aIter, &refPoint) ||
 277             !ReadParam(aMsg, aIter, &radius) ||
 278             !ReadParam(aMsg, aIter, &rotationAngle) ||
 279             !ReadParam(aMsg, aIter, &force)) {
 280           return false;
 281         }
 282         aResult->touches.AppendElement(
 283           new mozilla::dom::Touch(
 284             identifier, mozilla::LayoutDeviceIntPoint::ToUntyped(refPoint),
 285             radius, rotationAngle, force));
 286     }
 287     return true;
 288   }
 289 };
 290
 291 template<>
 292 struct ParamTraits<mozilla::WidgetKeyboardEvent>
 293 {
 294   typedef mozilla::WidgetKeyboardEvent paramType;
 295
 296   static void Write(Message* aMsg, const paramType& aParam)
 297   {
 298     WriteParam(aMsg, static_cast<mozilla::WidgetInputEvent>(aParam));
 299     WriteParam(aMsg, static_cast<uint32_t>(aParam.mKeyNameIndex));
 300     WriteParam(aMsg, aParam.keyCode);
 301     WriteParam(aMsg, aParam.charCode);
 302     WriteParam(aMsg, aParam.isChar);
 303     WriteParam(aMsg, aParam.mIsRepeat);
 304     WriteParam(aMsg, aParam.location);
 305     WriteParam(aMsg, aParam.mUniqueId);
 306     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 307     // that cannot be copied across process boundaries.
 308   }
 309
 310   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 311   {
 312     uint32_t keyNameIndex = 0;
 313     if (ReadParam(aMsg, aIter,
 314                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 315         ReadParam(aMsg, aIter, &keyNameIndex) &&
 316         ReadParam(aMsg, aIter, &aResult->keyCode) &&
 317         ReadParam(aMsg, aIter, &aResult->charCode) &&
 318         ReadParam(aMsg, aIter, &aResult->isChar) &&
 319         ReadParam(aMsg, aIter, &aResult->mIsRepeat) &&
 320         ReadParam(aMsg, aIter, &aResult->location) &&
 321         ReadParam(aMsg, aIter, &aResult->mUniqueId))
 322     {
 323       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 324       aResult->mNativeKeyEvent = nullptr;
 325       return true;
 326     }
 327     return false;
 328   }
 329 };
 330
 331 template<>
 332 struct ParamTraits<mozilla::TextRangeStyle>
 333 {
 334   typedef mozilla::TextRangeStyle paramType;
 335
 336   static void Write(Message* aMsg, const paramType& aParam)
 337   {
 338     WriteParam(aMsg, aParam.mDefinedStyles);
 339     WriteParam(aMsg, aParam.mLineStyle);
 340     WriteParam(aMsg, aParam.mIsBoldLine);
 341     WriteParam(aMsg, aParam.mForegroundColor);
 342     WriteParam(aMsg, aParam.mBackgroundColor);
 343     WriteParam(aMsg, aParam.mUnderlineColor);
 344   }
 345
 346   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 347   {
 348     return ReadParam(aMsg, aIter, &aResult->mDefinedStyles) &&
 349            ReadParam(aMsg, aIter, &aResult->mLineStyle) &&
 350            ReadParam(aMsg, aIter, &aResult->mIsBoldLine) &&
 351            ReadParam(aMsg, aIter, &aResult->mForegroundColor) &&
 352            ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
 353            ReadParam(aMsg, aIter, &aResult->mUnderlineColor);
 354   }
 355 };
 356
 357 template<>
 358 struct ParamTraits<mozilla::TextRange>
 359 {
 360   typedef mozilla::TextRange paramType;
 361
 362   static void Write(Message* aMsg, const paramType& aParam)
 363   {
 364     WriteParam(aMsg, aParam.mStartOffset);
 365     WriteParam(aMsg, aParam.mEndOffset);
 366     WriteParam(aMsg, aParam.mRangeType);
 367     WriteParam(aMsg, aParam.mRangeStyle);
 368   }
 369
 370   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 371   {
 372     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 373            ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 374            ReadParam(aMsg, aIter, &aResult->mRangeType) &&
 375            ReadParam(aMsg, aIter, &aResult->mRangeStyle);
 376   }
 377 };
 378
 379 template<>
 380 struct ParamTraits<mozilla::WidgetTextEvent>
 381 {
 382   typedef mozilla::WidgetTextEvent paramType;
 383
 384   static void Write(Message* aMsg, const paramType& aParam)
 385   {
 386     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 387     WriteParam(aMsg, aParam.seqno);
 388     WriteParam(aMsg, aParam.theText);
 389     WriteParam(aMsg, aParam.isChar);
 390     WriteParam(aMsg, aParam.rangeCount);
 391     for (uint32_t index = 0; index < aParam.rangeCount; index++)
 392       WriteParam(aMsg, aParam.rangeArray[index]);
 393   }
 394
 395   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 396   {
 397     if (!ReadParam(aMsg, aIter,
 398                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 399         !ReadParam(aMsg, aIter, &aResult->seqno) ||
 400         !ReadParam(aMsg, aIter, &aResult->theText) ||
 401         !ReadParam(aMsg, aIter, &aResult->isChar) ||
 402         !ReadParam(aMsg, aIter, &aResult->rangeCount))
 403       return false;
 404
 405     if (!aResult->rangeCount) {
 406       aResult->rangeArray = nullptr;
 407       return true;
 408     }
 409
 410     aResult->rangeArray = new mozilla::TextRange[aResult->rangeCount];
 411     if (!aResult->rangeArray)
 412       return false;
 413
 414     for (uint32_t index = 0; index < aResult->rangeCount; index++)
 415       if (!ReadParam(aMsg, aIter, &aResult->rangeArray[index])) {
 416         Free(*aResult);
 417         return false;
 418       }
 419     return true;
 420   }
 421
 422   static void Free(const paramType& aResult)
 423   {
 424     if (aResult.rangeArray)
 425       delete [] aResult.rangeArray;
 426   }
 427 };
 428
 429 template<>
 430 struct ParamTraits<mozilla::WidgetCompositionEvent>
 431 {
 432   typedef mozilla::WidgetCompositionEvent paramType;
 433
 434   static void Write(Message* aMsg, const paramType& aParam)
 435   {
 436     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 437     WriteParam(aMsg, aParam.seqno);
 438     WriteParam(aMsg, aParam.data);
 439   }
 440
 441   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 442   {
 443     return ReadParam(aMsg, aIter,
 444                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 445            ReadParam(aMsg, aIter, &aResult->seqno) &&
 446            ReadParam(aMsg, aIter, &aResult->data);
 447   }
 448 };
 449
 450 template<>
 451 struct ParamTraits<mozilla::WidgetQueryContentEvent>
 452 {
 453   typedef mozilla::WidgetQueryContentEvent paramType;
 454
 455   static void Write(Message* aMsg, const paramType& aParam)
 456   {
 457     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 458     WriteParam(aMsg, aParam.mSucceeded);
 459     WriteParam(aMsg, aParam.mInput.mOffset);
 460     WriteParam(aMsg, aParam.mInput.mLength);
 461     WriteParam(aMsg, aParam.mReply.mOffset);
 462     WriteParam(aMsg, aParam.mReply.mString);
 463     WriteParam(aMsg, aParam.mReply.mRect);
 464     WriteParam(aMsg, aParam.mReply.mReversed);
 465     WriteParam(aMsg, aParam.mReply.mHasSelection);
 466     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 467   }
 468
 469   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 470   {
 471     aResult->mWasAsync = true;
 472     return ReadParam(aMsg, aIter,
 473                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 474            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 475            ReadParam(aMsg, aIter, &aResult->mInput.mOffset) &&
 476            ReadParam(aMsg, aIter, &aResult->mInput.mLength) &&
 477            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 478            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 479            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 480            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 481            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 482            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit);
 483   }
 484 };
 485
 486 template<>
 487 struct ParamTraits<mozilla::WidgetSelectionEvent>
 488 {
 489   typedef mozilla::WidgetSelectionEvent paramType;
 490
 491   static void Write(Message* aMsg, const paramType& aParam)
 492   {
 493     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 494     WriteParam(aMsg, aParam.seqno);
 495     WriteParam(aMsg, aParam.mOffset);
 496     WriteParam(aMsg, aParam.mLength);
 497     WriteParam(aMsg, aParam.mReversed);
 498     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 499     WriteParam(aMsg, aParam.mSucceeded);
 500   }
 501
 502   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 503   {
 504     return ReadParam(aMsg, aIter,
 505                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 506            ReadParam(aMsg, aIter, &aResult->seqno) &&
 507            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 508            ReadParam(aMsg, aIter, &aResult->mLength) &&
 509            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 510            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 511            ReadParam(aMsg, aIter, &aResult->mSucceeded);
 512   }
 513 };
 514
 515 template<>
 516 struct ParamTraits<nsIMEUpdatePreference>
 517 {
 518   typedef nsIMEUpdatePreference paramType;
 519
 520   static void Write(Message* aMsg, const paramType& aParam)
 521   {
 522     WriteParam(aMsg, aParam.mWantUpdates);
 523     WriteParam(aMsg, aParam.mWantHints);
 524   }
 525
 526   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 527   {
 528     return ReadParam(aMsg, aIter, &aResult->mWantUpdates) &&
 529            ReadParam(aMsg, aIter, &aResult->mWantHints);
 530   }
 531 };
 532
 533 template<>
 534 struct ParamTraits<mozilla::WidgetPluginEvent>
 535 {
 536   typedef mozilla::WidgetPluginEvent paramType;
 537
 538   static void Write(Message* aMsg, const paramType& aParam)
 539   {
 540     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 541     WriteParam(aMsg, aParam.retargetToFocusedDocument);
 542   }
 543
 544   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 545   {
 546     return ReadParam(aMsg, aIter,
 547                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 548            ReadParam(aMsg, aIter, &aResult->retargetToFocusedDocument);
 549   }
 550 };
 551
 552 } // namespace IPC
 553
 554 #endif // nsGUIEventIPC_h__
 555