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