1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4  * License, v. 2.0. If a copy of the MPL was not distributed with this
5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 
7 #ifndef mozilla_dom_gamepad_GamepadMessageUtils_h
8 #define mozilla_dom_gamepad_GamepadMessageUtils_h
9 
10 #include "ipc/EnumSerializer.h"
11 #include "mozilla/dom/GamepadBinding.h"
12 #include "mozilla/dom/GamepadHandle.h"
13 #include "mozilla/dom/GamepadLightIndicatorBinding.h"
14 #include "mozilla/dom/GamepadPoseState.h"
15 #include "mozilla/dom/GamepadTouchState.h"
16 
17 namespace IPC {
18 
19 template <>
20 struct ParamTraits<mozilla::dom::GamepadLightIndicatorType>
21     : public ContiguousEnumSerializer<
22           mozilla::dom::GamepadLightIndicatorType,
23           mozilla::dom::GamepadLightIndicatorType(0),
24           mozilla::dom::GamepadLightIndicatorType(
25               mozilla::dom::GamepadLightIndicatorType::EndGuard_)> {};
26 
27 template <>
28 struct ParamTraits<mozilla::dom::GamepadMappingType>
29     : public ContiguousEnumSerializer<
30           mozilla::dom::GamepadMappingType, mozilla::dom::GamepadMappingType(0),
31           mozilla::dom::GamepadMappingType(
32               mozilla::dom::GamepadMappingType::EndGuard_)> {};
33 
34 template <>
35 struct ParamTraits<mozilla::dom::GamepadHand>
36     : public ContiguousEnumSerializer<
37           mozilla::dom::GamepadHand, mozilla::dom::GamepadHand(0),
38           mozilla::dom::GamepadHand(mozilla::dom::GamepadHand::EndGuard_)> {};
39 
40 template <>
41 struct ParamTraits<mozilla::dom::GamepadCapabilityFlags>
42     : public BitFlagsEnumSerializer<
43           mozilla::dom::GamepadCapabilityFlags,
44           mozilla::dom::GamepadCapabilityFlags::Cap_All> {};
45 
46 template <>
47 struct ParamTraits<mozilla::dom::GamepadPoseState> {
48   typedef mozilla::dom::GamepadPoseState paramType;
49 
50   static void Write(Message* aMsg, const paramType& aParam) {
51     WriteParam(aMsg, aParam.flags);
52     WriteParam(aMsg, aParam.orientation[0]);
53     WriteParam(aMsg, aParam.orientation[1]);
54     WriteParam(aMsg, aParam.orientation[2]);
55     WriteParam(aMsg, aParam.orientation[3]);
56     WriteParam(aMsg, aParam.position[0]);
57     WriteParam(aMsg, aParam.position[1]);
58     WriteParam(aMsg, aParam.position[2]);
59     WriteParam(aMsg, aParam.angularVelocity[0]);
60     WriteParam(aMsg, aParam.angularVelocity[1]);
61     WriteParam(aMsg, aParam.angularVelocity[2]);
62     WriteParam(aMsg, aParam.angularAcceleration[0]);
63     WriteParam(aMsg, aParam.angularAcceleration[1]);
64     WriteParam(aMsg, aParam.angularAcceleration[2]);
65     WriteParam(aMsg, aParam.linearVelocity[0]);
66     WriteParam(aMsg, aParam.linearVelocity[1]);
67     WriteParam(aMsg, aParam.linearVelocity[2]);
68     WriteParam(aMsg, aParam.linearAcceleration[0]);
69     WriteParam(aMsg, aParam.linearAcceleration[1]);
70     WriteParam(aMsg, aParam.linearAcceleration[2]);
71     WriteParam(aMsg, aParam.isPositionValid);
72     WriteParam(aMsg, aParam.isOrientationValid);
73   }
74 
75   static bool Read(const Message* aMsg, PickleIterator* aIter,
76                    paramType* aResult) {
77     if (!ReadParam(aMsg, aIter, &(aResult->flags)) ||
78         !ReadParam(aMsg, aIter, &(aResult->orientation[0])) ||
79         !ReadParam(aMsg, aIter, &(aResult->orientation[1])) ||
80         !ReadParam(aMsg, aIter, &(aResult->orientation[2])) ||
81         !ReadParam(aMsg, aIter, &(aResult->orientation[3])) ||
82         !ReadParam(aMsg, aIter, &(aResult->position[0])) ||
83         !ReadParam(aMsg, aIter, &(aResult->position[1])) ||
84         !ReadParam(aMsg, aIter, &(aResult->position[2])) ||
85         !ReadParam(aMsg, aIter, &(aResult->angularVelocity[0])) ||
86         !ReadParam(aMsg, aIter, &(aResult->angularVelocity[1])) ||
87         !ReadParam(aMsg, aIter, &(aResult->angularVelocity[2])) ||
88         !ReadParam(aMsg, aIter, &(aResult->angularAcceleration[0])) ||
89         !ReadParam(aMsg, aIter, &(aResult->angularAcceleration[1])) ||
90         !ReadParam(aMsg, aIter, &(aResult->angularAcceleration[2])) ||
91         !ReadParam(aMsg, aIter, &(aResult->linearVelocity[0])) ||
92         !ReadParam(aMsg, aIter, &(aResult->linearVelocity[1])) ||
93         !ReadParam(aMsg, aIter, &(aResult->linearVelocity[2])) ||
94         !ReadParam(aMsg, aIter, &(aResult->linearAcceleration[0])) ||
95         !ReadParam(aMsg, aIter, &(aResult->linearAcceleration[1])) ||
96         !ReadParam(aMsg, aIter, &(aResult->linearAcceleration[2])) ||
97         !ReadParam(aMsg, aIter, &(aResult->isPositionValid)) ||
98         !ReadParam(aMsg, aIter, &(aResult->isOrientationValid))) {
99       return false;
100     }
101     return true;
102   }
103 };
104 
105 template <>
106 struct ParamTraits<mozilla::dom::GamepadTouchState> {
107   typedef mozilla::dom::GamepadTouchState paramType;
108 
109   static void Write(Message* aMsg, const paramType& aParam) {
110     WriteParam(aMsg, aParam.touchId);
111     WriteParam(aMsg, aParam.surfaceId);
112     WriteParam(aMsg, aParam.position[0]);
113     WriteParam(aMsg, aParam.position[1]);
114     WriteParam(aMsg, aParam.surfaceDimensions[0]);
115     WriteParam(aMsg, aParam.surfaceDimensions[1]);
116     WriteParam(aMsg, aParam.isSurfaceDimensionsValid);
117   }
118 
119   static bool Read(const Message* aMsg, PickleIterator* aIter,
120                    paramType* aResult) {
121     if (!ReadParam(aMsg, aIter, &(aResult->touchId)) ||
122         !ReadParam(aMsg, aIter, &(aResult->surfaceId)) ||
123         !ReadParam(aMsg, aIter, &(aResult->position[0])) ||
124         !ReadParam(aMsg, aIter, &(aResult->position[1])) ||
125         !ReadParam(aMsg, aIter, &(aResult->surfaceDimensions[0])) ||
126         !ReadParam(aMsg, aIter, &(aResult->surfaceDimensions[1])) ||
127         !ReadParam(aMsg, aIter, &(aResult->isSurfaceDimensionsValid))) {
128       return false;
129     }
130     return true;
131   }
132 };
133 
134 template <>
135 struct ParamTraits<mozilla::dom::GamepadHandleKind>
136     : public ContiguousEnumSerializerInclusive<
137           mozilla::dom::GamepadHandleKind,
138           mozilla::dom::GamepadHandleKind::GamepadPlatformManager,
139           mozilla::dom::GamepadHandleKind::VR> {};
140 
141 template <>
142 struct ParamTraits<mozilla::dom::GamepadHandle> {
143   typedef mozilla::dom::GamepadHandle paramType;
144   static void Write(Message* aMsg, const paramType& aParam) {
145     WriteParam(aMsg, aParam.mValue);
146     WriteParam(aMsg, aParam.mKind);
147   }
148   static bool Read(const Message* aMsg, PickleIterator* aIter,
149                    paramType* aParam) {
150     return ReadParam(aMsg, aIter, &aParam->mValue) &&
151            ReadParam(aMsg, aIter, &aParam->mKind);
152   }
153 };
154 
155 }  // namespace IPC
156 
157 #endif  // mozilla_dom_gamepad_GamepadMessageUtils_h
158