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.mKeyValue);
 301     WriteParam(aMsg, aParam.keyCode);
 302     WriteParam(aMsg, aParam.charCode);
 303     WriteParam(aMsg, aParam.isChar);
 304     WriteParam(aMsg, aParam.mIsRepeat);
 305     WriteParam(aMsg, aParam.location);
 306     WriteParam(aMsg, aParam.mUniqueId);
 307     // An OS-specific native event might be attached in |mNativeKeyEvent|,  but
 308     // that cannot be copied across process boundaries.
 309   }
 310
 311   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 312   {
 313     uint32_t keyNameIndex = 0;
 314     if (ReadParam(aMsg, aIter,
 315                   static_cast<mozilla::WidgetInputEvent*>(aResult)) &&
 316         ReadParam(aMsg, aIter, &keyNameIndex) &&
 317         ReadParam(aMsg, aIter, &aResult->mKeyValue) &&
 318         ReadParam(aMsg, aIter, &aResult->keyCode) &&
 319         ReadParam(aMsg, aIter, &aResult->charCode) &&
 320         ReadParam(aMsg, aIter, &aResult->isChar) &&
 321         ReadParam(aMsg, aIter, &aResult->mIsRepeat) &&
 322         ReadParam(aMsg, aIter, &aResult->location) &&
 323         ReadParam(aMsg, aIter, &aResult->mUniqueId))
 324     {
 325       aResult->mKeyNameIndex = static_cast<mozilla::KeyNameIndex>(keyNameIndex);
 326       aResult->mNativeKeyEvent = nullptr;
 327       return true;
 328     }
 329     return false;
 330   }
 331 };
 332
 333 template<>
 334 struct ParamTraits<mozilla::TextRangeStyle>
 335 {
 336   typedef mozilla::TextRangeStyle paramType;
 337
 338   static void Write(Message* aMsg, const paramType& aParam)
 339   {
 340     WriteParam(aMsg, aParam.mDefinedStyles);
 341     WriteParam(aMsg, aParam.mLineStyle);
 342     WriteParam(aMsg, aParam.mIsBoldLine);
 343     WriteParam(aMsg, aParam.mForegroundColor);
 344     WriteParam(aMsg, aParam.mBackgroundColor);
 345     WriteParam(aMsg, aParam.mUnderlineColor);
 346   }
 347
 348   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 349   {
 350     return ReadParam(aMsg, aIter, &aResult->mDefinedStyles) &&
 351            ReadParam(aMsg, aIter, &aResult->mLineStyle) &&
 352            ReadParam(aMsg, aIter, &aResult->mIsBoldLine) &&
 353            ReadParam(aMsg, aIter, &aResult->mForegroundColor) &&
 354            ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
 355            ReadParam(aMsg, aIter, &aResult->mUnderlineColor);
 356   }
 357 };
 358
 359 template<>
 360 struct ParamTraits<mozilla::TextRange>
 361 {
 362   typedef mozilla::TextRange paramType;
 363
 364   static void Write(Message* aMsg, const paramType& aParam)
 365   {
 366     WriteParam(aMsg, aParam.mStartOffset);
 367     WriteParam(aMsg, aParam.mEndOffset);
 368     WriteParam(aMsg, aParam.mRangeType);
 369     WriteParam(aMsg, aParam.mRangeStyle);
 370   }
 371
 372   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 373   {
 374     return ReadParam(aMsg, aIter, &aResult->mStartOffset) &&
 375            ReadParam(aMsg, aIter, &aResult->mEndOffset) &&
 376            ReadParam(aMsg, aIter, &aResult->mRangeType) &&
 377            ReadParam(aMsg, aIter, &aResult->mRangeStyle);
 378   }
 379 };
 380
 381 template<>
 382 struct ParamTraits<mozilla::WidgetTextEvent>
 383 {
 384   typedef mozilla::WidgetTextEvent paramType;
 385
 386   static void Write(Message* aMsg, const paramType& aParam)
 387   {
 388     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 389     WriteParam(aMsg, aParam.mSeqno);
 390     WriteParam(aMsg, aParam.theText);
 391     WriteParam(aMsg, aParam.isChar);
 392     WriteParam(aMsg, aParam.rangeCount);
 393     for (uint32_t index = 0; index < aParam.rangeCount; index++)
 394       WriteParam(aMsg, aParam.rangeArray[index]);
 395   }
 396
 397   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 398   {
 399     if (!ReadParam(aMsg, aIter,
 400                    static_cast<mozilla::WidgetGUIEvent*>(aResult)) ||
 401         !ReadParam(aMsg, aIter, &aResult->mSeqno) ||
 402         !ReadParam(aMsg, aIter, &aResult->theText) ||
 403         !ReadParam(aMsg, aIter, &aResult->isChar) ||
 404         !ReadParam(aMsg, aIter, &aResult->rangeCount))
 405       return false;
 406
 407     if (!aResult->rangeCount) {
 408       aResult->rangeArray = nullptr;
 409       return true;
 410     }
 411
 412     aResult->rangeArray = new mozilla::TextRange[aResult->rangeCount];
 413     if (!aResult->rangeArray)
 414       return false;
 415
 416     for (uint32_t index = 0; index < aResult->rangeCount; index++)
 417       if (!ReadParam(aMsg, aIter, &aResult->rangeArray[index])) {
 418         Free(*aResult);
 419         return false;
 420       }
 421     return true;
 422   }
 423
 424   static void Free(const paramType& aResult)
 425   {
 426     if (aResult.rangeArray)
 427       delete [] aResult.rangeArray;
 428   }
 429 };
 430
 431 template<>
 432 struct ParamTraits<mozilla::WidgetCompositionEvent>
 433 {
 434   typedef mozilla::WidgetCompositionEvent paramType;
 435
 436   static void Write(Message* aMsg, const paramType& aParam)
 437   {
 438     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 439     WriteParam(aMsg, aParam.mSeqno);
 440     WriteParam(aMsg, aParam.data);
 441   }
 442
 443   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 444   {
 445     return ReadParam(aMsg, aIter,
 446                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 447            ReadParam(aMsg, aIter, &aResult->mSeqno) &&
 448            ReadParam(aMsg, aIter, &aResult->data);
 449   }
 450 };
 451
 452 template<>
 453 struct ParamTraits<mozilla::WidgetQueryContentEvent>
 454 {
 455   typedef mozilla::WidgetQueryContentEvent paramType;
 456
 457   static void Write(Message* aMsg, const paramType& aParam)
 458   {
 459     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 460     WriteParam(aMsg, aParam.mSucceeded);
 461     WriteParam(aMsg, aParam.mInput.mOffset);
 462     WriteParam(aMsg, aParam.mInput.mLength);
 463     WriteParam(aMsg, aParam.mReply.mOffset);
 464     WriteParam(aMsg, aParam.mReply.mString);
 465     WriteParam(aMsg, aParam.mReply.mRect);
 466     WriteParam(aMsg, aParam.mReply.mReversed);
 467     WriteParam(aMsg, aParam.mReply.mHasSelection);
 468     WriteParam(aMsg, aParam.mReply.mWidgetIsHit);
 469   }
 470
 471   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 472   {
 473     aResult->mWasAsync = true;
 474     return ReadParam(aMsg, aIter,
 475                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 476            ReadParam(aMsg, aIter, &aResult->mSucceeded) &&
 477            ReadParam(aMsg, aIter, &aResult->mInput.mOffset) &&
 478            ReadParam(aMsg, aIter, &aResult->mInput.mLength) &&
 479            ReadParam(aMsg, aIter, &aResult->mReply.mOffset) &&
 480            ReadParam(aMsg, aIter, &aResult->mReply.mString) &&
 481            ReadParam(aMsg, aIter, &aResult->mReply.mRect) &&
 482            ReadParam(aMsg, aIter, &aResult->mReply.mReversed) &&
 483            ReadParam(aMsg, aIter, &aResult->mReply.mHasSelection) &&
 484            ReadParam(aMsg, aIter, &aResult->mReply.mWidgetIsHit);
 485   }
 486 };
 487
 488 template<>
 489 struct ParamTraits<mozilla::WidgetSelectionEvent>
 490 {
 491   typedef mozilla::WidgetSelectionEvent paramType;
 492
 493   static void Write(Message* aMsg, const paramType& aParam)
 494   {
 495     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 496     WriteParam(aMsg, aParam.mSeqno);
 497     WriteParam(aMsg, aParam.mOffset);
 498     WriteParam(aMsg, aParam.mLength);
 499     WriteParam(aMsg, aParam.mReversed);
 500     WriteParam(aMsg, aParam.mExpandToClusterBoundary);
 501     WriteParam(aMsg, aParam.mSucceeded);
 502   }
 503
 504   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 505   {
 506     return ReadParam(aMsg, aIter,
 507                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 508            ReadParam(aMsg, aIter, &aResult->mSeqno) &&
 509            ReadParam(aMsg, aIter, &aResult->mOffset) &&
 510            ReadParam(aMsg, aIter, &aResult->mLength) &&
 511            ReadParam(aMsg, aIter, &aResult->mReversed) &&
 512            ReadParam(aMsg, aIter, &aResult->mExpandToClusterBoundary) &&
 513            ReadParam(aMsg, aIter, &aResult->mSucceeded);
 514   }
 515 };
 516
 517 template<>
 518 struct ParamTraits<nsIMEUpdatePreference>
 519 {
 520   typedef nsIMEUpdatePreference paramType;
 521
 522   static void Write(Message* aMsg, const paramType& aParam)
 523   {
 524     WriteParam(aMsg, aParam.mWantUpdates);
 525     WriteParam(aMsg, aParam.mWantHints);
 526   }
 527
 528   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 529   {
 530     return ReadParam(aMsg, aIter, &aResult->mWantUpdates) &&
 531            ReadParam(aMsg, aIter, &aResult->mWantHints);
 532   }
 533 };
 534
 535 template<>
 536 struct ParamTraits<mozilla::WidgetPluginEvent>
 537 {
 538   typedef mozilla::WidgetPluginEvent paramType;
 539
 540   static void Write(Message* aMsg, const paramType& aParam)
 541   {
 542     WriteParam(aMsg, static_cast<mozilla::WidgetGUIEvent>(aParam));
 543     WriteParam(aMsg, aParam.retargetToFocusedDocument);
 544   }
 545
 546   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 547   {
 548     return ReadParam(aMsg, aIter,
 549                      static_cast<mozilla::WidgetGUIEvent*>(aResult)) &&
 550            ReadParam(aMsg, aIter, &aResult->retargetToFocusedDocument);
 551   }
 552 };
 553
 554 } // namespace IPC
 555
 556 #endif // nsGUIEventIPC_h__
 557