Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/layers/WebRenderMessages.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |union OptionalTransform|
12 : //
13 : namespace mozilla {
14 : namespace layers {
15 0 : auto OptionalTransform::MaybeDestroy(Type aNewType) -> bool
16 : {
17 0 : if ((mType) == (T__None)) {
18 0 : return true;
19 : }
20 0 : if ((mType) == (aNewType)) {
21 0 : return false;
22 : }
23 0 : switch (mType) {
24 : case TMatrix4x4:
25 : {
26 0 : (ptr_Matrix4x4())->~Matrix4x4__tdef();
27 0 : break;
28 : }
29 : case Tvoid_t:
30 : {
31 0 : (ptr_void_t())->~void_t__tdef();
32 0 : break;
33 : }
34 : default:
35 : {
36 0 : mozilla::ipc::LogicError("not reached");
37 0 : break;
38 : }
39 : }
40 0 : return true;
41 : }
42 :
43 0 : MOZ_IMPLICIT OptionalTransform::OptionalTransform(const Matrix4x4& aOther)
44 : {
45 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(aOther);
46 0 : mType = TMatrix4x4;
47 0 : }
48 :
49 0 : MOZ_IMPLICIT OptionalTransform::OptionalTransform(const void_t& aOther)
50 : {
51 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
52 0 : mType = Tvoid_t;
53 0 : }
54 :
55 0 : MOZ_IMPLICIT OptionalTransform::OptionalTransform(const OptionalTransform& aOther)
56 : {
57 0 : (aOther).AssertSanity();
58 0 : switch ((aOther).type()) {
59 : case TMatrix4x4:
60 : {
61 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aOther).get_Matrix4x4());
62 0 : break;
63 : }
64 : case Tvoid_t:
65 : {
66 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
67 0 : break;
68 : }
69 : case T__None:
70 : {
71 0 : break;
72 : }
73 : default:
74 : {
75 0 : mozilla::ipc::LogicError("unreached");
76 0 : return;
77 : }
78 : }
79 0 : mType = (aOther).type();
80 : }
81 :
82 0 : OptionalTransform::~OptionalTransform()
83 : {
84 0 : static_cast<void>(MaybeDestroy(T__None));
85 0 : }
86 :
87 0 : auto OptionalTransform::operator=(const Matrix4x4& aRhs) -> OptionalTransform&
88 : {
89 0 : if (MaybeDestroy(TMatrix4x4)) {
90 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
91 : }
92 0 : (*(ptr_Matrix4x4())) = aRhs;
93 0 : mType = TMatrix4x4;
94 0 : return (*(this));
95 : }
96 :
97 0 : auto OptionalTransform::operator=(const void_t& aRhs) -> OptionalTransform&
98 : {
99 0 : if (MaybeDestroy(Tvoid_t)) {
100 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
101 : }
102 0 : (*(ptr_void_t())) = aRhs;
103 0 : mType = Tvoid_t;
104 0 : return (*(this));
105 : }
106 :
107 0 : auto OptionalTransform::operator=(const OptionalTransform& aRhs) -> OptionalTransform&
108 : {
109 0 : (aRhs).AssertSanity();
110 0 : Type t = (aRhs).type();
111 0 : switch (t) {
112 : case TMatrix4x4:
113 : {
114 0 : if (MaybeDestroy(t)) {
115 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
116 : }
117 0 : (*(ptr_Matrix4x4())) = (aRhs).get_Matrix4x4();
118 0 : break;
119 : }
120 : case Tvoid_t:
121 : {
122 0 : if (MaybeDestroy(t)) {
123 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
124 : }
125 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
126 0 : break;
127 : }
128 : case T__None:
129 : {
130 0 : static_cast<void>(MaybeDestroy(t));
131 0 : break;
132 : }
133 : default:
134 : {
135 0 : mozilla::ipc::LogicError("unreached");
136 0 : break;
137 : }
138 : }
139 0 : mType = t;
140 0 : return (*(this));
141 : }
142 :
143 0 : auto OptionalTransform::operator==(const Matrix4x4& aRhs) const -> bool
144 : {
145 0 : return (get_Matrix4x4()) == (aRhs);
146 : }
147 :
148 0 : auto OptionalTransform::operator==(const void_t& aRhs) const -> bool
149 : {
150 0 : return (get_void_t()) == (aRhs);
151 : }
152 :
153 0 : auto OptionalTransform::operator==(const OptionalTransform& aRhs) const -> bool
154 : {
155 0 : if ((type()) != ((aRhs).type())) {
156 0 : return false;
157 : }
158 :
159 0 : switch (type()) {
160 : case TMatrix4x4:
161 : {
162 0 : return (get_Matrix4x4()) == ((aRhs).get_Matrix4x4());
163 : }
164 : case Tvoid_t:
165 : {
166 0 : return (get_void_t()) == ((aRhs).get_void_t());
167 : }
168 : default:
169 : {
170 0 : mozilla::ipc::LogicError("unreached");
171 0 : return false;
172 : }
173 : }
174 : }
175 :
176 0 : auto OptionalTransform::get(Matrix4x4* aOutValue) const -> void
177 : {
178 0 : (*(aOutValue)) = get_Matrix4x4();
179 0 : }
180 :
181 0 : auto OptionalTransform::get(void_t* aOutValue) const -> void
182 : {
183 0 : (*(aOutValue)) = get_void_t();
184 0 : }
185 :
186 : } // namespace layers
187 : } // namespace mozilla
188 :
189 : //-----------------------------------------------------------------------------
190 : // Method definitions for the IPDL type |union OptionalOpacity|
191 : //
192 : namespace mozilla {
193 : namespace layers {
194 0 : auto OptionalOpacity::MaybeDestroy(Type aNewType) -> bool
195 : {
196 0 : if ((mType) == (T__None)) {
197 0 : return true;
198 : }
199 0 : if ((mType) == (aNewType)) {
200 0 : return false;
201 : }
202 0 : switch (mType) {
203 : case Tfloat:
204 : {
205 0 : (ptr_float())->~float__tdef();
206 0 : break;
207 : }
208 : case Tvoid_t:
209 : {
210 0 : (ptr_void_t())->~void_t__tdef();
211 0 : break;
212 : }
213 : default:
214 : {
215 0 : mozilla::ipc::LogicError("not reached");
216 0 : break;
217 : }
218 : }
219 0 : return true;
220 : }
221 :
222 0 : MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(const float& aOther)
223 : {
224 0 : new (mozilla::KnownNotNull, ptr_float()) float(aOther);
225 0 : mType = Tfloat;
226 0 : }
227 :
228 0 : MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(const void_t& aOther)
229 : {
230 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
231 0 : mType = Tvoid_t;
232 0 : }
233 :
234 0 : MOZ_IMPLICIT OptionalOpacity::OptionalOpacity(const OptionalOpacity& aOther)
235 : {
236 0 : (aOther).AssertSanity();
237 0 : switch ((aOther).type()) {
238 : case Tfloat:
239 : {
240 0 : new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
241 0 : break;
242 : }
243 : case Tvoid_t:
244 : {
245 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
246 0 : break;
247 : }
248 : case T__None:
249 : {
250 0 : break;
251 : }
252 : default:
253 : {
254 0 : mozilla::ipc::LogicError("unreached");
255 0 : return;
256 : }
257 : }
258 0 : mType = (aOther).type();
259 : }
260 :
261 0 : OptionalOpacity::~OptionalOpacity()
262 : {
263 0 : static_cast<void>(MaybeDestroy(T__None));
264 0 : }
265 :
266 0 : auto OptionalOpacity::operator=(const float& aRhs) -> OptionalOpacity&
267 : {
268 0 : if (MaybeDestroy(Tfloat)) {
269 0 : new (mozilla::KnownNotNull, ptr_float()) float;
270 : }
271 0 : (*(ptr_float())) = aRhs;
272 0 : mType = Tfloat;
273 0 : return (*(this));
274 : }
275 :
276 0 : auto OptionalOpacity::operator=(const void_t& aRhs) -> OptionalOpacity&
277 : {
278 0 : if (MaybeDestroy(Tvoid_t)) {
279 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
280 : }
281 0 : (*(ptr_void_t())) = aRhs;
282 0 : mType = Tvoid_t;
283 0 : return (*(this));
284 : }
285 :
286 0 : auto OptionalOpacity::operator=(const OptionalOpacity& aRhs) -> OptionalOpacity&
287 : {
288 0 : (aRhs).AssertSanity();
289 0 : Type t = (aRhs).type();
290 0 : switch (t) {
291 : case Tfloat:
292 : {
293 0 : if (MaybeDestroy(t)) {
294 0 : new (mozilla::KnownNotNull, ptr_float()) float;
295 : }
296 0 : (*(ptr_float())) = (aRhs).get_float();
297 0 : break;
298 : }
299 : case Tvoid_t:
300 : {
301 0 : if (MaybeDestroy(t)) {
302 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
303 : }
304 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
305 0 : break;
306 : }
307 : case T__None:
308 : {
309 0 : static_cast<void>(MaybeDestroy(t));
310 0 : break;
311 : }
312 : default:
313 : {
314 0 : mozilla::ipc::LogicError("unreached");
315 0 : break;
316 : }
317 : }
318 0 : mType = t;
319 0 : return (*(this));
320 : }
321 :
322 0 : auto OptionalOpacity::operator==(const float& aRhs) const -> bool
323 : {
324 0 : return (get_float()) == (aRhs);
325 : }
326 :
327 0 : auto OptionalOpacity::operator==(const void_t& aRhs) const -> bool
328 : {
329 0 : return (get_void_t()) == (aRhs);
330 : }
331 :
332 0 : auto OptionalOpacity::operator==(const OptionalOpacity& aRhs) const -> bool
333 : {
334 0 : if ((type()) != ((aRhs).type())) {
335 0 : return false;
336 : }
337 :
338 0 : switch (type()) {
339 : case Tfloat:
340 : {
341 0 : return (get_float()) == ((aRhs).get_float());
342 : }
343 : case Tvoid_t:
344 : {
345 0 : return (get_void_t()) == ((aRhs).get_void_t());
346 : }
347 : default:
348 : {
349 0 : mozilla::ipc::LogicError("unreached");
350 0 : return false;
351 : }
352 : }
353 : }
354 :
355 0 : auto OptionalOpacity::get(float* aOutValue) const -> void
356 : {
357 0 : (*(aOutValue)) = get_float();
358 0 : }
359 :
360 0 : auto OptionalOpacity::get(void_t* aOutValue) const -> void
361 : {
362 0 : (*(aOutValue)) = get_void_t();
363 0 : }
364 :
365 : } // namespace layers
366 : } // namespace mozilla
367 :
368 : //-----------------------------------------------------------------------------
369 : // Method definitions for the IPDL type |struct OpAddExternalImage|
370 : //
371 : namespace mozilla {
372 : namespace layers {
373 0 : MOZ_IMPLICIT OpAddExternalImage::OpAddExternalImage() :
374 : externalImageId_(),
375 0 : key_()
376 : {
377 0 : Init();
378 0 : }
379 :
380 0 : OpAddExternalImage::~OpAddExternalImage()
381 : {
382 0 : }
383 :
384 0 : auto OpAddExternalImage::operator==(const OpAddExternalImage& _o) const -> bool
385 : {
386 0 : if ((!((externalImageId()) == ((_o).externalImageId())))) {
387 0 : return false;
388 : }
389 0 : if ((!((key()) == ((_o).key())))) {
390 0 : return false;
391 : }
392 0 : return true;
393 : }
394 :
395 0 : auto OpAddExternalImage::operator!=(const OpAddExternalImage& _o) const -> bool
396 : {
397 0 : return (!(operator==(_o)));
398 : }
399 :
400 0 : auto OpAddExternalImage::Init() -> void
401 : {
402 0 : }
403 :
404 0 : auto OpAddExternalImage::Assign(
405 : const ExternalImageId& _externalImageId,
406 : const ImageKey& _key) -> void
407 : {
408 0 : externalImageId_ = _externalImageId;
409 0 : key_ = _key;
410 0 : }
411 :
412 : } // namespace layers
413 : } // namespace mozilla
414 :
415 : //-----------------------------------------------------------------------------
416 : // Method definitions for the IPDL type |struct OpAddCompositorAnimations|
417 : //
418 : namespace mozilla {
419 : namespace layers {
420 0 : MOZ_IMPLICIT OpAddCompositorAnimations::OpAddCompositorAnimations()
421 : {
422 0 : Init();
423 0 : }
424 :
425 0 : OpAddCompositorAnimations::~OpAddCompositorAnimations()
426 : {
427 0 : }
428 :
429 0 : auto OpAddCompositorAnimations::operator==(const OpAddCompositorAnimations& _o) const -> bool
430 : {
431 0 : if ((!((data()) == ((_o).data())))) {
432 0 : return false;
433 : }
434 0 : if ((!((transform()) == ((_o).transform())))) {
435 0 : return false;
436 : }
437 0 : if ((!((opacity()) == ((_o).opacity())))) {
438 0 : return false;
439 : }
440 0 : return true;
441 : }
442 :
443 0 : auto OpAddCompositorAnimations::operator!=(const OpAddCompositorAnimations& _o) const -> bool
444 : {
445 0 : return (!(operator==(_o)));
446 : }
447 :
448 0 : auto OpAddCompositorAnimations::Init() -> void
449 : {
450 0 : }
451 :
452 0 : auto OpAddCompositorAnimations::Assign(
453 : const CompositorAnimations& _data,
454 : const OptionalTransform& _transform,
455 : const OptionalOpacity& _opacity) -> void
456 : {
457 0 : data_ = _data;
458 0 : transform_ = _transform;
459 0 : opacity_ = _opacity;
460 0 : }
461 :
462 : } // namespace layers
463 : } // namespace mozilla
464 :
465 : //-----------------------------------------------------------------------------
466 : // Method definitions for the IPDL type |struct OpUpdateAsyncImagePipeline|
467 : //
468 : namespace mozilla {
469 : namespace layers {
470 0 : MOZ_IMPLICIT OpUpdateAsyncImagePipeline::OpUpdateAsyncImagePipeline() :
471 : pipelineId_(),
472 : scBounds_(),
473 : scTransform_(),
474 : scaleToSize_(),
475 : filter_(),
476 0 : mixBlendMode_()
477 : {
478 0 : Init();
479 0 : }
480 :
481 0 : OpUpdateAsyncImagePipeline::~OpUpdateAsyncImagePipeline()
482 : {
483 0 : }
484 :
485 0 : auto OpUpdateAsyncImagePipeline::operator==(const OpUpdateAsyncImagePipeline& _o) const -> bool
486 : {
487 0 : if ((!((pipelineId()) == ((_o).pipelineId())))) {
488 0 : return false;
489 : }
490 0 : if ((!((scBounds()) == ((_o).scBounds())))) {
491 0 : return false;
492 : }
493 0 : if ((!((scTransform()) == ((_o).scTransform())))) {
494 0 : return false;
495 : }
496 0 : if ((!((scaleToSize()) == ((_o).scaleToSize())))) {
497 0 : return false;
498 : }
499 0 : if ((!((filter()) == ((_o).filter())))) {
500 0 : return false;
501 : }
502 0 : if ((!((mixBlendMode()) == ((_o).mixBlendMode())))) {
503 0 : return false;
504 : }
505 0 : return true;
506 : }
507 :
508 0 : auto OpUpdateAsyncImagePipeline::operator!=(const OpUpdateAsyncImagePipeline& _o) const -> bool
509 : {
510 0 : return (!(operator==(_o)));
511 : }
512 :
513 0 : auto OpUpdateAsyncImagePipeline::Init() -> void
514 : {
515 0 : }
516 :
517 0 : auto OpUpdateAsyncImagePipeline::Assign(
518 : const PipelineId& _pipelineId,
519 : const LayerRect& _scBounds,
520 : const Matrix4x4& _scTransform,
521 : const MaybeIntSize& _scaleToSize,
522 : const WrImageRendering& _filter,
523 : const WrMixBlendMode& _mixBlendMode) -> void
524 : {
525 0 : pipelineId_ = _pipelineId;
526 0 : scBounds_ = _scBounds;
527 0 : scTransform_ = _scTransform;
528 0 : scaleToSize_ = _scaleToSize;
529 0 : filter_ = _filter;
530 0 : mixBlendMode_ = _mixBlendMode;
531 0 : }
532 :
533 : } // namespace layers
534 : } // namespace mozilla
535 :
536 : //-----------------------------------------------------------------------------
537 : // Method definitions for the IPDL type |union WebRenderParentCommand|
538 : //
539 : namespace mozilla {
540 : namespace layers {
541 0 : auto WebRenderParentCommand::MaybeDestroy(Type aNewType) -> bool
542 : {
543 0 : if ((mType) == (T__None)) {
544 0 : return true;
545 : }
546 0 : if ((mType) == (aNewType)) {
547 0 : return false;
548 : }
549 0 : switch (mType) {
550 : case TOpAddExternalImage:
551 : {
552 0 : (ptr_OpAddExternalImage())->~OpAddExternalImage__tdef();
553 0 : break;
554 : }
555 : case TOpUpdateAsyncImagePipeline:
556 : {
557 0 : (ptr_OpUpdateAsyncImagePipeline())->~OpUpdateAsyncImagePipeline__tdef();
558 0 : break;
559 : }
560 : case TCompositableOperation:
561 : {
562 0 : (ptr_CompositableOperation())->~CompositableOperation__tdef();
563 0 : break;
564 : }
565 : case TOpAddCompositorAnimations:
566 : {
567 0 : (ptr_OpAddCompositorAnimations())->~OpAddCompositorAnimations__tdef();
568 0 : break;
569 : }
570 : default:
571 : {
572 0 : mozilla::ipc::LogicError("not reached");
573 0 : break;
574 : }
575 : }
576 0 : return true;
577 : }
578 :
579 0 : MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpAddExternalImage& aOther)
580 : {
581 0 : new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage(aOther);
582 0 : mType = TOpAddExternalImage;
583 0 : }
584 :
585 0 : MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpUpdateAsyncImagePipeline& aOther)
586 : {
587 0 : new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline(aOther);
588 0 : mType = TOpUpdateAsyncImagePipeline;
589 0 : }
590 :
591 0 : MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const CompositableOperation& aOther)
592 : {
593 0 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(aOther);
594 0 : mType = TCompositableOperation;
595 0 : }
596 :
597 0 : MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const OpAddCompositorAnimations& aOther)
598 : {
599 0 : new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations(aOther);
600 0 : mType = TOpAddCompositorAnimations;
601 0 : }
602 :
603 0 : MOZ_IMPLICIT WebRenderParentCommand::WebRenderParentCommand(const WebRenderParentCommand& aOther)
604 : {
605 0 : (aOther).AssertSanity();
606 0 : switch ((aOther).type()) {
607 : case TOpAddExternalImage:
608 : {
609 0 : new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage((aOther).get_OpAddExternalImage());
610 0 : break;
611 : }
612 : case TOpUpdateAsyncImagePipeline:
613 : {
614 0 : new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline((aOther).get_OpUpdateAsyncImagePipeline());
615 0 : break;
616 : }
617 : case TCompositableOperation:
618 : {
619 0 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation((aOther).get_CompositableOperation());
620 0 : break;
621 : }
622 : case TOpAddCompositorAnimations:
623 : {
624 0 : new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations((aOther).get_OpAddCompositorAnimations());
625 0 : break;
626 : }
627 : case T__None:
628 : {
629 0 : break;
630 : }
631 : default:
632 : {
633 0 : mozilla::ipc::LogicError("unreached");
634 0 : return;
635 : }
636 : }
637 0 : mType = (aOther).type();
638 : }
639 :
640 0 : WebRenderParentCommand::~WebRenderParentCommand()
641 : {
642 0 : static_cast<void>(MaybeDestroy(T__None));
643 0 : }
644 :
645 0 : auto WebRenderParentCommand::operator=(const OpAddExternalImage& aRhs) -> WebRenderParentCommand&
646 : {
647 0 : if (MaybeDestroy(TOpAddExternalImage)) {
648 0 : new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
649 : }
650 0 : (*(ptr_OpAddExternalImage())) = aRhs;
651 0 : mType = TOpAddExternalImage;
652 0 : return (*(this));
653 : }
654 :
655 0 : auto WebRenderParentCommand::operator=(const OpUpdateAsyncImagePipeline& aRhs) -> WebRenderParentCommand&
656 : {
657 0 : if (MaybeDestroy(TOpUpdateAsyncImagePipeline)) {
658 0 : new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
659 : }
660 0 : (*(ptr_OpUpdateAsyncImagePipeline())) = aRhs;
661 0 : mType = TOpUpdateAsyncImagePipeline;
662 0 : return (*(this));
663 : }
664 :
665 0 : auto WebRenderParentCommand::operator=(const CompositableOperation& aRhs) -> WebRenderParentCommand&
666 : {
667 0 : if (MaybeDestroy(TCompositableOperation)) {
668 0 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
669 : }
670 0 : (*(ptr_CompositableOperation())) = aRhs;
671 0 : mType = TCompositableOperation;
672 0 : return (*(this));
673 : }
674 :
675 0 : auto WebRenderParentCommand::operator=(const OpAddCompositorAnimations& aRhs) -> WebRenderParentCommand&
676 : {
677 0 : if (MaybeDestroy(TOpAddCompositorAnimations)) {
678 0 : new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
679 : }
680 0 : (*(ptr_OpAddCompositorAnimations())) = aRhs;
681 0 : mType = TOpAddCompositorAnimations;
682 0 : return (*(this));
683 : }
684 :
685 0 : auto WebRenderParentCommand::operator=(const WebRenderParentCommand& aRhs) -> WebRenderParentCommand&
686 : {
687 0 : (aRhs).AssertSanity();
688 0 : Type t = (aRhs).type();
689 0 : switch (t) {
690 : case TOpAddExternalImage:
691 : {
692 0 : if (MaybeDestroy(t)) {
693 0 : new (mozilla::KnownNotNull, ptr_OpAddExternalImage()) OpAddExternalImage;
694 : }
695 0 : (*(ptr_OpAddExternalImage())) = (aRhs).get_OpAddExternalImage();
696 0 : break;
697 : }
698 : case TOpUpdateAsyncImagePipeline:
699 : {
700 0 : if (MaybeDestroy(t)) {
701 0 : new (mozilla::KnownNotNull, ptr_OpUpdateAsyncImagePipeline()) OpUpdateAsyncImagePipeline;
702 : }
703 0 : (*(ptr_OpUpdateAsyncImagePipeline())) = (aRhs).get_OpUpdateAsyncImagePipeline();
704 0 : break;
705 : }
706 : case TCompositableOperation:
707 : {
708 0 : if (MaybeDestroy(t)) {
709 0 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
710 : }
711 0 : (*(ptr_CompositableOperation())) = (aRhs).get_CompositableOperation();
712 0 : break;
713 : }
714 : case TOpAddCompositorAnimations:
715 : {
716 0 : if (MaybeDestroy(t)) {
717 0 : new (mozilla::KnownNotNull, ptr_OpAddCompositorAnimations()) OpAddCompositorAnimations;
718 : }
719 0 : (*(ptr_OpAddCompositorAnimations())) = (aRhs).get_OpAddCompositorAnimations();
720 0 : break;
721 : }
722 : case T__None:
723 : {
724 0 : static_cast<void>(MaybeDestroy(t));
725 0 : break;
726 : }
727 : default:
728 : {
729 0 : mozilla::ipc::LogicError("unreached");
730 0 : break;
731 : }
732 : }
733 0 : mType = t;
734 0 : return (*(this));
735 : }
736 :
737 0 : auto WebRenderParentCommand::operator==(const OpAddExternalImage& aRhs) const -> bool
738 : {
739 0 : return (get_OpAddExternalImage()) == (aRhs);
740 : }
741 :
742 0 : auto WebRenderParentCommand::operator==(const OpUpdateAsyncImagePipeline& aRhs) const -> bool
743 : {
744 0 : return (get_OpUpdateAsyncImagePipeline()) == (aRhs);
745 : }
746 :
747 0 : auto WebRenderParentCommand::operator==(const CompositableOperation& aRhs) const -> bool
748 : {
749 0 : return (get_CompositableOperation()) == (aRhs);
750 : }
751 :
752 0 : auto WebRenderParentCommand::operator==(const OpAddCompositorAnimations& aRhs) const -> bool
753 : {
754 0 : return (get_OpAddCompositorAnimations()) == (aRhs);
755 : }
756 :
757 0 : auto WebRenderParentCommand::operator==(const WebRenderParentCommand& aRhs) const -> bool
758 : {
759 0 : if ((type()) != ((aRhs).type())) {
760 0 : return false;
761 : }
762 :
763 0 : switch (type()) {
764 : case TOpAddExternalImage:
765 : {
766 0 : return (get_OpAddExternalImage()) == ((aRhs).get_OpAddExternalImage());
767 : }
768 : case TOpUpdateAsyncImagePipeline:
769 : {
770 0 : return (get_OpUpdateAsyncImagePipeline()) == ((aRhs).get_OpUpdateAsyncImagePipeline());
771 : }
772 : case TCompositableOperation:
773 : {
774 0 : return (get_CompositableOperation()) == ((aRhs).get_CompositableOperation());
775 : }
776 : case TOpAddCompositorAnimations:
777 : {
778 0 : return (get_OpAddCompositorAnimations()) == ((aRhs).get_OpAddCompositorAnimations());
779 : }
780 : default:
781 : {
782 0 : mozilla::ipc::LogicError("unreached");
783 0 : return false;
784 : }
785 : }
786 : }
787 :
788 0 : auto WebRenderParentCommand::get(OpAddExternalImage* aOutValue) const -> void
789 : {
790 0 : (*(aOutValue)) = get_OpAddExternalImage();
791 0 : }
792 :
793 0 : auto WebRenderParentCommand::get(OpUpdateAsyncImagePipeline* aOutValue) const -> void
794 : {
795 0 : (*(aOutValue)) = get_OpUpdateAsyncImagePipeline();
796 0 : }
797 :
798 0 : auto WebRenderParentCommand::get(CompositableOperation* aOutValue) const -> void
799 : {
800 0 : (*(aOutValue)) = get_CompositableOperation();
801 0 : }
802 :
803 0 : auto WebRenderParentCommand::get(OpAddCompositorAnimations* aOutValue) const -> void
804 : {
805 0 : (*(aOutValue)) = get_OpAddCompositorAnimations();
806 0 : }
807 :
808 : } // namespace layers
809 : } // namespace mozilla
|
