Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/layers/PCompositorManager.h"
8 :
9 : namespace mozilla {
10 : namespace layers {
11 : namespace PCompositorManager {
12 :
13 : nsresult
14 2 : CreateEndpoints(
15 : base::ProcessId aParentDestPid,
16 : base::ProcessId aChildDestPid,
17 : mozilla::ipc::Endpoint<mozilla::layers::PCompositorManagerParent>* aParent,
18 : mozilla::ipc::Endpoint<mozilla::layers::PCompositorManagerChild>* aChild)
19 : {
20 2 : return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, PCompositorManagerMsgStart, PCompositorManagerMsgStartChild, aParent, aChild);
21 : }
22 : void
23 5 : Transition(
24 : MessageType msg,
25 : State* next)
26 : {
27 5 : switch ((*(next))) {
28 : case __Null:
29 5 : break;
30 : case __Dead:
31 0 : mozilla::ipc::LogicError("__delete__()d actor");
32 0 : break;
33 : default:
34 0 : mozilla::ipc::LogicError("corrupted actor state");
35 0 : break;
36 : }
37 5 : }
38 : IPC::Message*
39 3 : Msg_PCompositorBridgeConstructor(int32_t routingId)
40 : {
41 3 : return new IPC::Message(routingId, Msg_PCompositorBridgeConstructor__ID, 0, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PCompositorManager::Msg_PCompositorBridgeConstructor", true);
42 : }
43 : IPC::Message*
44 0 : Reply_PCompositorBridgeConstructor(int32_t routingId)
45 : {
46 0 : return new IPC::Message(routingId, Reply_PCompositorBridgeConstructor__ID, 0, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PCompositorManager::Reply_PCompositorBridgeConstructor", true);
47 : }
48 :
49 : } // namespace PCompositorManager
50 : } // namespace layers
51 : } // namespace mozilla
52 :
53 : //-----------------------------------------------------------------------------
54 : // Method definitions for the IPDL type |struct WidgetCompositorOptions|
55 : //
56 : namespace mozilla {
57 : namespace layers {
58 0 : MOZ_IMPLICIT WidgetCompositorOptions::WidgetCompositorOptions() :
59 : scale_(),
60 : vsyncRate_(),
61 : options_(),
62 : useExternalSurfaceSize_(),
63 0 : surfaceSize_()
64 : {
65 0 : Init();
66 0 : }
67 :
68 0 : WidgetCompositorOptions::~WidgetCompositorOptions()
69 : {
70 0 : }
71 :
72 0 : auto WidgetCompositorOptions::operator==(const WidgetCompositorOptions& _o) const -> bool
73 : {
74 0 : if ((!((scale()) == ((_o).scale())))) {
75 0 : return false;
76 : }
77 0 : if ((!((vsyncRate()) == ((_o).vsyncRate())))) {
78 0 : return false;
79 : }
80 0 : if ((!((options()) == ((_o).options())))) {
81 0 : return false;
82 : }
83 0 : if ((!((useExternalSurfaceSize()) == ((_o).useExternalSurfaceSize())))) {
84 0 : return false;
85 : }
86 0 : if ((!((surfaceSize()) == ((_o).surfaceSize())))) {
87 0 : return false;
88 : }
89 0 : return true;
90 : }
91 :
92 0 : auto WidgetCompositorOptions::operator!=(const WidgetCompositorOptions& _o) const -> bool
93 : {
94 0 : return (!(operator==(_o)));
95 : }
96 :
97 0 : auto WidgetCompositorOptions::Init() -> void
98 : {
99 0 : }
100 :
101 0 : auto WidgetCompositorOptions::Assign(
102 : const CSSToLayoutDeviceScale& _scale,
103 : const TimeDuration& _vsyncRate,
104 : const CompositorOptions& _options,
105 : const bool& _useExternalSurfaceSize,
106 : const IntSize& _surfaceSize) -> void
107 : {
108 0 : scale_ = _scale;
109 0 : vsyncRate_ = _vsyncRate;
110 0 : options_ = _options;
111 0 : useExternalSurfaceSize_ = _useExternalSurfaceSize;
112 0 : surfaceSize_ = _surfaceSize;
113 0 : }
114 :
115 : } // namespace layers
116 : } // namespace mozilla
117 :
118 : //-----------------------------------------------------------------------------
119 : // Method definitions for the IPDL type |struct ContentCompositorOptions|
120 : //
121 : namespace mozilla {
122 : namespace layers {
123 6 : ContentCompositorOptions::~ContentCompositorOptions()
124 : {
125 6 : }
126 :
127 0 : auto ContentCompositorOptions::operator==(const ContentCompositorOptions& _o) const -> bool
128 : {
129 0 : return true;
130 : }
131 :
132 0 : auto ContentCompositorOptions::operator!=(const ContentCompositorOptions& _o) const -> bool
133 : {
134 0 : return (!(operator==(_o)));
135 : }
136 :
137 6 : auto ContentCompositorOptions::Init() -> void
138 : {
139 6 : }
140 :
141 7 : auto ContentCompositorOptions::Assign() -> void
142 : {
143 7 : }
144 :
145 : } // namespace layers
146 : } // namespace mozilla
147 :
148 : //-----------------------------------------------------------------------------
149 : // Method definitions for the IPDL type |struct SameProcessWidgetCompositorOptions|
150 : //
151 : namespace mozilla {
152 : namespace layers {
153 4 : SameProcessWidgetCompositorOptions::~SameProcessWidgetCompositorOptions()
154 : {
155 4 : }
156 :
157 0 : auto SameProcessWidgetCompositorOptions::operator==(const SameProcessWidgetCompositorOptions& _o) const -> bool
158 : {
159 0 : return true;
160 : }
161 :
162 0 : auto SameProcessWidgetCompositorOptions::operator!=(const SameProcessWidgetCompositorOptions& _o) const -> bool
163 : {
164 0 : return (!(operator==(_o)));
165 : }
166 :
167 4 : auto SameProcessWidgetCompositorOptions::Init() -> void
168 : {
169 4 : }
170 :
171 5 : auto SameProcessWidgetCompositorOptions::Assign() -> void
172 : {
173 5 : }
174 :
175 : } // namespace layers
176 : } // namespace mozilla
177 :
178 : //-----------------------------------------------------------------------------
179 : // Method definitions for the IPDL type |union CompositorBridgeOptions|
180 : //
181 : namespace mozilla {
182 : namespace layers {
183 7 : auto CompositorBridgeOptions::MaybeDestroy(Type aNewType) -> bool
184 : {
185 7 : if ((mType) == (T__None)) {
186 2 : return true;
187 : }
188 5 : if ((mType) == (aNewType)) {
189 0 : return false;
190 : }
191 5 : switch (mType) {
192 : case TContentCompositorOptions:
193 : {
194 3 : (ptr_ContentCompositorOptions())->~ContentCompositorOptions__tdef();
195 3 : break;
196 : }
197 : case TWidgetCompositorOptions:
198 : {
199 0 : (ptr_WidgetCompositorOptions())->~WidgetCompositorOptions__tdef();
200 0 : break;
201 : }
202 : case TSameProcessWidgetCompositorOptions:
203 : {
204 2 : (ptr_SameProcessWidgetCompositorOptions())->~SameProcessWidgetCompositorOptions__tdef();
205 2 : break;
206 : }
207 : default:
208 : {
209 0 : mozilla::ipc::LogicError("not reached");
210 0 : break;
211 : }
212 : }
213 5 : return true;
214 : }
215 :
216 2 : MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const ContentCompositorOptions& aOther)
217 : {
218 2 : new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions(aOther);
219 2 : mType = TContentCompositorOptions;
220 2 : }
221 :
222 0 : MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const WidgetCompositorOptions& aOther)
223 : {
224 0 : new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions(aOther);
225 0 : mType = TWidgetCompositorOptions;
226 0 : }
227 :
228 1 : MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const SameProcessWidgetCompositorOptions& aOther)
229 : {
230 1 : new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions(aOther);
231 1 : mType = TSameProcessWidgetCompositorOptions;
232 1 : }
233 :
234 0 : MOZ_IMPLICIT CompositorBridgeOptions::CompositorBridgeOptions(const CompositorBridgeOptions& aOther)
235 : {
236 0 : (aOther).AssertSanity();
237 0 : switch ((aOther).type()) {
238 : case TContentCompositorOptions:
239 : {
240 0 : new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions((aOther).get_ContentCompositorOptions());
241 0 : break;
242 : }
243 : case TWidgetCompositorOptions:
244 : {
245 0 : new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions((aOther).get_WidgetCompositorOptions());
246 0 : break;
247 : }
248 : case TSameProcessWidgetCompositorOptions:
249 : {
250 0 : new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions((aOther).get_SameProcessWidgetCompositorOptions());
251 0 : break;
252 : }
253 : case T__None:
254 : {
255 0 : break;
256 : }
257 : default:
258 : {
259 0 : mozilla::ipc::LogicError("unreached");
260 0 : return;
261 : }
262 : }
263 0 : mType = (aOther).type();
264 : }
265 :
266 10 : CompositorBridgeOptions::~CompositorBridgeOptions()
267 : {
268 5 : static_cast<void>(MaybeDestroy(T__None));
269 5 : }
270 :
271 1 : auto CompositorBridgeOptions::operator=(const ContentCompositorOptions& aRhs) -> CompositorBridgeOptions&
272 : {
273 1 : if (MaybeDestroy(TContentCompositorOptions)) {
274 1 : new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
275 : }
276 1 : (*(ptr_ContentCompositorOptions())) = aRhs;
277 1 : mType = TContentCompositorOptions;
278 1 : return (*(this));
279 : }
280 :
281 0 : auto CompositorBridgeOptions::operator=(const WidgetCompositorOptions& aRhs) -> CompositorBridgeOptions&
282 : {
283 0 : if (MaybeDestroy(TWidgetCompositorOptions)) {
284 0 : new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
285 : }
286 0 : (*(ptr_WidgetCompositorOptions())) = aRhs;
287 0 : mType = TWidgetCompositorOptions;
288 0 : return (*(this));
289 : }
290 :
291 1 : auto CompositorBridgeOptions::operator=(const SameProcessWidgetCompositorOptions& aRhs) -> CompositorBridgeOptions&
292 : {
293 1 : if (MaybeDestroy(TSameProcessWidgetCompositorOptions)) {
294 1 : new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
295 : }
296 1 : (*(ptr_SameProcessWidgetCompositorOptions())) = aRhs;
297 1 : mType = TSameProcessWidgetCompositorOptions;
298 1 : return (*(this));
299 : }
300 :
301 0 : auto CompositorBridgeOptions::operator=(const CompositorBridgeOptions& aRhs) -> CompositorBridgeOptions&
302 : {
303 0 : (aRhs).AssertSanity();
304 0 : Type t = (aRhs).type();
305 0 : switch (t) {
306 : case TContentCompositorOptions:
307 : {
308 0 : if (MaybeDestroy(t)) {
309 0 : new (mozilla::KnownNotNull, ptr_ContentCompositorOptions()) ContentCompositorOptions;
310 : }
311 0 : (*(ptr_ContentCompositorOptions())) = (aRhs).get_ContentCompositorOptions();
312 0 : break;
313 : }
314 : case TWidgetCompositorOptions:
315 : {
316 0 : if (MaybeDestroy(t)) {
317 0 : new (mozilla::KnownNotNull, ptr_WidgetCompositorOptions()) WidgetCompositorOptions;
318 : }
319 0 : (*(ptr_WidgetCompositorOptions())) = (aRhs).get_WidgetCompositorOptions();
320 0 : break;
321 : }
322 : case TSameProcessWidgetCompositorOptions:
323 : {
324 0 : if (MaybeDestroy(t)) {
325 0 : new (mozilla::KnownNotNull, ptr_SameProcessWidgetCompositorOptions()) SameProcessWidgetCompositorOptions;
326 : }
327 0 : (*(ptr_SameProcessWidgetCompositorOptions())) = (aRhs).get_SameProcessWidgetCompositorOptions();
328 0 : break;
329 : }
330 : case T__None:
331 : {
332 0 : static_cast<void>(MaybeDestroy(t));
333 0 : break;
334 : }
335 : default:
336 : {
337 0 : mozilla::ipc::LogicError("unreached");
338 0 : break;
339 : }
340 : }
341 0 : mType = t;
342 0 : return (*(this));
343 : }
344 :
345 0 : auto CompositorBridgeOptions::operator==(const ContentCompositorOptions& aRhs) const -> bool
346 : {
347 0 : return (get_ContentCompositorOptions()) == (aRhs);
348 : }
349 :
350 0 : auto CompositorBridgeOptions::operator==(const WidgetCompositorOptions& aRhs) const -> bool
351 : {
352 0 : return (get_WidgetCompositorOptions()) == (aRhs);
353 : }
354 :
355 0 : auto CompositorBridgeOptions::operator==(const SameProcessWidgetCompositorOptions& aRhs) const -> bool
356 : {
357 0 : return (get_SameProcessWidgetCompositorOptions()) == (aRhs);
358 : }
359 :
360 0 : auto CompositorBridgeOptions::operator==(const CompositorBridgeOptions& aRhs) const -> bool
361 : {
362 0 : if ((type()) != ((aRhs).type())) {
363 0 : return false;
364 : }
365 :
366 0 : switch (type()) {
367 : case TContentCompositorOptions:
368 : {
369 0 : return (get_ContentCompositorOptions()) == ((aRhs).get_ContentCompositorOptions());
370 : }
371 : case TWidgetCompositorOptions:
372 : {
373 0 : return (get_WidgetCompositorOptions()) == ((aRhs).get_WidgetCompositorOptions());
374 : }
375 : case TSameProcessWidgetCompositorOptions:
376 : {
377 0 : return (get_SameProcessWidgetCompositorOptions()) == ((aRhs).get_SameProcessWidgetCompositorOptions());
378 : }
379 : default:
380 : {
381 0 : mozilla::ipc::LogicError("unreached");
382 0 : return false;
383 : }
384 : }
385 : }
386 :
387 0 : auto CompositorBridgeOptions::get(ContentCompositorOptions* aOutValue) const -> void
388 : {
389 0 : (*(aOutValue)) = get_ContentCompositorOptions();
390 0 : }
391 :
392 0 : auto CompositorBridgeOptions::get(WidgetCompositorOptions* aOutValue) const -> void
393 : {
394 0 : (*(aOutValue)) = get_WidgetCompositorOptions();
395 0 : }
396 :
397 0 : auto CompositorBridgeOptions::get(SameProcessWidgetCompositorOptions* aOutValue) const -> void
398 : {
399 0 : (*(aOutValue)) = get_SameProcessWidgetCompositorOptions();
400 0 : }
401 :
402 : } // namespace layers
403 : } // namespace mozilla
|
