Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/layers/LayersMessages.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |struct TargetConfig|
12 : //
13 : namespace mozilla {
14 : namespace layers {
15 60 : MOZ_IMPLICIT TargetConfig::TargetConfig() :
16 : naturalBounds_(),
17 : rotation_(),
18 : orientation_(),
19 60 : clearRegion_()
20 : {
21 60 : Init();
22 60 : }
23 :
24 85 : TargetConfig::~TargetConfig()
25 : {
26 85 : }
27 :
28 0 : auto TargetConfig::operator==(const TargetConfig& _o) const -> bool
29 : {
30 0 : if ((!((naturalBounds()) == ((_o).naturalBounds())))) {
31 0 : return false;
32 : }
33 0 : if ((!((rotation()) == ((_o).rotation())))) {
34 0 : return false;
35 : }
36 0 : if ((!((orientation()) == ((_o).orientation())))) {
37 0 : return false;
38 : }
39 0 : if ((!((clearRegion()) == ((_o).clearRegion())))) {
40 0 : return false;
41 : }
42 0 : return true;
43 : }
44 :
45 0 : auto TargetConfig::operator!=(const TargetConfig& _o) const -> bool
46 : {
47 0 : return (!(operator==(_o)));
48 : }
49 :
50 88 : auto TargetConfig::Init() -> void
51 : {
52 88 : }
53 :
54 84 : auto TargetConfig::Assign(
55 : const IntRect& _naturalBounds,
56 : const ScreenRotation& _rotation,
57 : const ScreenOrientationInternal& _orientation,
58 : const nsIntRegion& _clearRegion) -> void
59 : {
60 84 : naturalBounds_ = _naturalBounds;
61 84 : rotation_ = _rotation;
62 84 : orientation_ = _orientation;
63 84 : clearRegion_ = _clearRegion;
64 84 : }
65 :
66 : } // namespace layers
67 : } // namespace mozilla
68 :
69 : //-----------------------------------------------------------------------------
70 : // Method definitions for the IPDL type |struct OpCreatePaintedLayer|
71 : //
72 : namespace mozilla {
73 : namespace layers {
74 44 : MOZ_IMPLICIT OpCreatePaintedLayer::OpCreatePaintedLayer() :
75 44 : layer_()
76 : {
77 44 : Init();
78 44 : }
79 :
80 110 : OpCreatePaintedLayer::~OpCreatePaintedLayer()
81 : {
82 110 : }
83 :
84 0 : auto OpCreatePaintedLayer::operator==(const OpCreatePaintedLayer& _o) const -> bool
85 : {
86 0 : if ((!((layer()) == ((_o).layer())))) {
87 0 : return false;
88 : }
89 0 : return true;
90 : }
91 :
92 0 : auto OpCreatePaintedLayer::operator!=(const OpCreatePaintedLayer& _o) const -> bool
93 : {
94 0 : return (!(operator==(_o)));
95 : }
96 :
97 110 : auto OpCreatePaintedLayer::Init() -> void
98 : {
99 110 : }
100 :
101 88 : auto OpCreatePaintedLayer::Assign(const LayerHandle& _layer) -> void
102 : {
103 88 : layer_ = _layer;
104 88 : }
105 :
106 : } // namespace layers
107 : } // namespace mozilla
108 :
109 : //-----------------------------------------------------------------------------
110 : // Method definitions for the IPDL type |struct OpCreateContainerLayer|
111 : //
112 : namespace mozilla {
113 : namespace layers {
114 8 : MOZ_IMPLICIT OpCreateContainerLayer::OpCreateContainerLayer() :
115 8 : layer_()
116 : {
117 8 : Init();
118 8 : }
119 :
120 20 : OpCreateContainerLayer::~OpCreateContainerLayer()
121 : {
122 20 : }
123 :
124 0 : auto OpCreateContainerLayer::operator==(const OpCreateContainerLayer& _o) const -> bool
125 : {
126 0 : if ((!((layer()) == ((_o).layer())))) {
127 0 : return false;
128 : }
129 0 : return true;
130 : }
131 :
132 0 : auto OpCreateContainerLayer::operator!=(const OpCreateContainerLayer& _o) const -> bool
133 : {
134 0 : return (!(operator==(_o)));
135 : }
136 :
137 20 : auto OpCreateContainerLayer::Init() -> void
138 : {
139 20 : }
140 :
141 16 : auto OpCreateContainerLayer::Assign(const LayerHandle& _layer) -> void
142 : {
143 16 : layer_ = _layer;
144 16 : }
145 :
146 : } // namespace layers
147 : } // namespace mozilla
148 :
149 : //-----------------------------------------------------------------------------
150 : // Method definitions for the IPDL type |struct OpCreateImageLayer|
151 : //
152 : namespace mozilla {
153 : namespace layers {
154 0 : MOZ_IMPLICIT OpCreateImageLayer::OpCreateImageLayer() :
155 0 : layer_()
156 : {
157 0 : Init();
158 0 : }
159 :
160 0 : OpCreateImageLayer::~OpCreateImageLayer()
161 : {
162 0 : }
163 :
164 0 : auto OpCreateImageLayer::operator==(const OpCreateImageLayer& _o) const -> bool
165 : {
166 0 : if ((!((layer()) == ((_o).layer())))) {
167 0 : return false;
168 : }
169 0 : return true;
170 : }
171 :
172 0 : auto OpCreateImageLayer::operator!=(const OpCreateImageLayer& _o) const -> bool
173 : {
174 0 : return (!(operator==(_o)));
175 : }
176 :
177 0 : auto OpCreateImageLayer::Init() -> void
178 : {
179 0 : }
180 :
181 0 : auto OpCreateImageLayer::Assign(const LayerHandle& _layer) -> void
182 : {
183 0 : layer_ = _layer;
184 0 : }
185 :
186 : } // namespace layers
187 : } // namespace mozilla
188 :
189 : //-----------------------------------------------------------------------------
190 : // Method definitions for the IPDL type |struct OpCreateColorLayer|
191 : //
192 : namespace mozilla {
193 : namespace layers {
194 8 : MOZ_IMPLICIT OpCreateColorLayer::OpCreateColorLayer() :
195 8 : layer_()
196 : {
197 8 : Init();
198 8 : }
199 :
200 20 : OpCreateColorLayer::~OpCreateColorLayer()
201 : {
202 20 : }
203 :
204 0 : auto OpCreateColorLayer::operator==(const OpCreateColorLayer& _o) const -> bool
205 : {
206 0 : if ((!((layer()) == ((_o).layer())))) {
207 0 : return false;
208 : }
209 0 : return true;
210 : }
211 :
212 0 : auto OpCreateColorLayer::operator!=(const OpCreateColorLayer& _o) const -> bool
213 : {
214 0 : return (!(operator==(_o)));
215 : }
216 :
217 20 : auto OpCreateColorLayer::Init() -> void
218 : {
219 20 : }
220 :
221 16 : auto OpCreateColorLayer::Assign(const LayerHandle& _layer) -> void
222 : {
223 16 : layer_ = _layer;
224 16 : }
225 :
226 : } // namespace layers
227 : } // namespace mozilla
228 :
229 : //-----------------------------------------------------------------------------
230 : // Method definitions for the IPDL type |struct OpCreateTextLayer|
231 : //
232 : namespace mozilla {
233 : namespace layers {
234 0 : MOZ_IMPLICIT OpCreateTextLayer::OpCreateTextLayer() :
235 0 : layer_()
236 : {
237 0 : Init();
238 0 : }
239 :
240 0 : OpCreateTextLayer::~OpCreateTextLayer()
241 : {
242 0 : }
243 :
244 0 : auto OpCreateTextLayer::operator==(const OpCreateTextLayer& _o) const -> bool
245 : {
246 0 : if ((!((layer()) == ((_o).layer())))) {
247 0 : return false;
248 : }
249 0 : return true;
250 : }
251 :
252 0 : auto OpCreateTextLayer::operator!=(const OpCreateTextLayer& _o) const -> bool
253 : {
254 0 : return (!(operator==(_o)));
255 : }
256 :
257 0 : auto OpCreateTextLayer::Init() -> void
258 : {
259 0 : }
260 :
261 0 : auto OpCreateTextLayer::Assign(const LayerHandle& _layer) -> void
262 : {
263 0 : layer_ = _layer;
264 0 : }
265 :
266 : } // namespace layers
267 : } // namespace mozilla
268 :
269 : //-----------------------------------------------------------------------------
270 : // Method definitions for the IPDL type |struct OpCreateBorderLayer|
271 : //
272 : namespace mozilla {
273 : namespace layers {
274 0 : MOZ_IMPLICIT OpCreateBorderLayer::OpCreateBorderLayer() :
275 0 : layer_()
276 : {
277 0 : Init();
278 0 : }
279 :
280 0 : OpCreateBorderLayer::~OpCreateBorderLayer()
281 : {
282 0 : }
283 :
284 0 : auto OpCreateBorderLayer::operator==(const OpCreateBorderLayer& _o) const -> bool
285 : {
286 0 : if ((!((layer()) == ((_o).layer())))) {
287 0 : return false;
288 : }
289 0 : return true;
290 : }
291 :
292 0 : auto OpCreateBorderLayer::operator!=(const OpCreateBorderLayer& _o) const -> bool
293 : {
294 0 : return (!(operator==(_o)));
295 : }
296 :
297 0 : auto OpCreateBorderLayer::Init() -> void
298 : {
299 0 : }
300 :
301 0 : auto OpCreateBorderLayer::Assign(const LayerHandle& _layer) -> void
302 : {
303 0 : layer_ = _layer;
304 0 : }
305 :
306 : } // namespace layers
307 : } // namespace mozilla
308 :
309 : //-----------------------------------------------------------------------------
310 : // Method definitions for the IPDL type |struct OpCreateCanvasLayer|
311 : //
312 : namespace mozilla {
313 : namespace layers {
314 0 : MOZ_IMPLICIT OpCreateCanvasLayer::OpCreateCanvasLayer() :
315 0 : layer_()
316 : {
317 0 : Init();
318 0 : }
319 :
320 0 : OpCreateCanvasLayer::~OpCreateCanvasLayer()
321 : {
322 0 : }
323 :
324 0 : auto OpCreateCanvasLayer::operator==(const OpCreateCanvasLayer& _o) const -> bool
325 : {
326 0 : if ((!((layer()) == ((_o).layer())))) {
327 0 : return false;
328 : }
329 0 : return true;
330 : }
331 :
332 0 : auto OpCreateCanvasLayer::operator!=(const OpCreateCanvasLayer& _o) const -> bool
333 : {
334 0 : return (!(operator==(_o)));
335 : }
336 :
337 0 : auto OpCreateCanvasLayer::Init() -> void
338 : {
339 0 : }
340 :
341 0 : auto OpCreateCanvasLayer::Assign(const LayerHandle& _layer) -> void
342 : {
343 0 : layer_ = _layer;
344 0 : }
345 :
346 : } // namespace layers
347 : } // namespace mozilla
348 :
349 : //-----------------------------------------------------------------------------
350 : // Method definitions for the IPDL type |struct OpCreateRefLayer|
351 : //
352 : namespace mozilla {
353 : namespace layers {
354 2 : MOZ_IMPLICIT OpCreateRefLayer::OpCreateRefLayer() :
355 2 : layer_()
356 : {
357 2 : Init();
358 2 : }
359 :
360 5 : OpCreateRefLayer::~OpCreateRefLayer()
361 : {
362 5 : }
363 :
364 0 : auto OpCreateRefLayer::operator==(const OpCreateRefLayer& _o) const -> bool
365 : {
366 0 : if ((!((layer()) == ((_o).layer())))) {
367 0 : return false;
368 : }
369 0 : return true;
370 : }
371 :
372 0 : auto OpCreateRefLayer::operator!=(const OpCreateRefLayer& _o) const -> bool
373 : {
374 0 : return (!(operator==(_o)));
375 : }
376 :
377 5 : auto OpCreateRefLayer::Init() -> void
378 : {
379 5 : }
380 :
381 4 : auto OpCreateRefLayer::Assign(const LayerHandle& _layer) -> void
382 : {
383 4 : layer_ = _layer;
384 4 : }
385 :
386 : } // namespace layers
387 : } // namespace mozilla
388 :
389 : //-----------------------------------------------------------------------------
390 : // Method definitions for the IPDL type |struct OpAttachCompositable|
391 : //
392 : namespace mozilla {
393 : namespace layers {
394 44 : MOZ_IMPLICIT OpAttachCompositable::OpAttachCompositable() :
395 : layer_(),
396 44 : compositable_()
397 : {
398 44 : Init();
399 44 : }
400 :
401 110 : OpAttachCompositable::~OpAttachCompositable()
402 : {
403 110 : }
404 :
405 0 : auto OpAttachCompositable::operator==(const OpAttachCompositable& _o) const -> bool
406 : {
407 0 : if ((!((layer()) == ((_o).layer())))) {
408 0 : return false;
409 : }
410 0 : if ((!((compositable()) == ((_o).compositable())))) {
411 0 : return false;
412 : }
413 0 : return true;
414 : }
415 :
416 0 : auto OpAttachCompositable::operator!=(const OpAttachCompositable& _o) const -> bool
417 : {
418 0 : return (!(operator==(_o)));
419 : }
420 :
421 110 : auto OpAttachCompositable::Init() -> void
422 : {
423 110 : }
424 :
425 88 : auto OpAttachCompositable::Assign(
426 : const LayerHandle& _layer,
427 : const CompositableHandle& _compositable) -> void
428 : {
429 88 : layer_ = _layer;
430 88 : compositable_ = _compositable;
431 88 : }
432 :
433 : } // namespace layers
434 : } // namespace mozilla
435 :
436 : //-----------------------------------------------------------------------------
437 : // Method definitions for the IPDL type |struct OpAttachAsyncCompositable|
438 : //
439 : namespace mozilla {
440 : namespace layers {
441 0 : MOZ_IMPLICIT OpAttachAsyncCompositable::OpAttachAsyncCompositable() :
442 : layer_(),
443 0 : compositable_()
444 : {
445 0 : Init();
446 0 : }
447 :
448 0 : OpAttachAsyncCompositable::~OpAttachAsyncCompositable()
449 : {
450 0 : }
451 :
452 0 : auto OpAttachAsyncCompositable::operator==(const OpAttachAsyncCompositable& _o) const -> bool
453 : {
454 0 : if ((!((layer()) == ((_o).layer())))) {
455 0 : return false;
456 : }
457 0 : if ((!((compositable()) == ((_o).compositable())))) {
458 0 : return false;
459 : }
460 0 : return true;
461 : }
462 :
463 0 : auto OpAttachAsyncCompositable::operator!=(const OpAttachAsyncCompositable& _o) const -> bool
464 : {
465 0 : return (!(operator==(_o)));
466 : }
467 :
468 0 : auto OpAttachAsyncCompositable::Init() -> void
469 : {
470 0 : }
471 :
472 0 : auto OpAttachAsyncCompositable::Assign(
473 : const LayerHandle& _layer,
474 : const CompositableHandle& _compositable) -> void
475 : {
476 0 : layer_ = _layer;
477 0 : compositable_ = _compositable;
478 0 : }
479 :
480 : } // namespace layers
481 : } // namespace mozilla
482 :
483 : //-----------------------------------------------------------------------------
484 : // Method definitions for the IPDL type |struct ThebesBufferData|
485 : //
486 : namespace mozilla {
487 : namespace layers {
488 231 : MOZ_IMPLICIT ThebesBufferData::ThebesBufferData() :
489 : rect_(),
490 231 : rotation_()
491 : {
492 231 : Init();
493 231 : }
494 :
495 264 : ThebesBufferData::~ThebesBufferData()
496 : {
497 264 : }
498 :
499 0 : auto ThebesBufferData::operator==(const ThebesBufferData& _o) const -> bool
500 : {
501 0 : if ((!((rect()) == ((_o).rect())))) {
502 0 : return false;
503 : }
504 0 : if ((!((rotation()) == ((_o).rotation())))) {
505 0 : return false;
506 : }
507 0 : return true;
508 : }
509 :
510 0 : auto ThebesBufferData::operator!=(const ThebesBufferData& _o) const -> bool
511 : {
512 0 : return (!(operator==(_o)));
513 : }
514 :
515 264 : auto ThebesBufferData::Init() -> void
516 : {
517 264 : }
518 :
519 231 : auto ThebesBufferData::Assign(
520 : const IntRect& _rect,
521 : const IntPoint& _rotation) -> void
522 : {
523 231 : rect_ = _rect;
524 231 : rotation_ = _rotation;
525 231 : }
526 :
527 : } // namespace layers
528 : } // namespace mozilla
529 :
530 : //-----------------------------------------------------------------------------
531 : // Method definitions for the IPDL type |struct CubicBezierFunction|
532 : //
533 : namespace mozilla {
534 : namespace layers {
535 0 : MOZ_IMPLICIT CubicBezierFunction::CubicBezierFunction() :
536 : x1_(),
537 : y1_(),
538 : x2_(),
539 0 : y2_()
540 : {
541 0 : Init();
542 0 : }
543 :
544 0 : CubicBezierFunction::~CubicBezierFunction()
545 : {
546 0 : }
547 :
548 0 : auto CubicBezierFunction::operator==(const CubicBezierFunction& _o) const -> bool
549 : {
550 0 : if ((!((x1()) == ((_o).x1())))) {
551 0 : return false;
552 : }
553 0 : if ((!((y1()) == ((_o).y1())))) {
554 0 : return false;
555 : }
556 0 : if ((!((x2()) == ((_o).x2())))) {
557 0 : return false;
558 : }
559 0 : if ((!((y2()) == ((_o).y2())))) {
560 0 : return false;
561 : }
562 0 : return true;
563 : }
564 :
565 0 : auto CubicBezierFunction::operator!=(const CubicBezierFunction& _o) const -> bool
566 : {
567 0 : return (!(operator==(_o)));
568 : }
569 :
570 0 : auto CubicBezierFunction::Init() -> void
571 : {
572 0 : }
573 :
574 0 : auto CubicBezierFunction::Assign(
575 : const float& _x1,
576 : const float& _y1,
577 : const float& _x2,
578 : const float& _y2) -> void
579 : {
580 0 : x1_ = _x1;
581 0 : y1_ = _y1;
582 0 : x2_ = _x2;
583 0 : y2_ = _y2;
584 0 : }
585 :
586 : } // namespace layers
587 : } // namespace mozilla
588 :
589 : //-----------------------------------------------------------------------------
590 : // Method definitions for the IPDL type |struct StepFunction|
591 : //
592 : namespace mozilla {
593 : namespace layers {
594 0 : MOZ_IMPLICIT StepFunction::StepFunction() :
595 : steps_(),
596 0 : type_()
597 : {
598 0 : Init();
599 0 : }
600 :
601 0 : StepFunction::~StepFunction()
602 : {
603 0 : }
604 :
605 0 : auto StepFunction::operator==(const StepFunction& _o) const -> bool
606 : {
607 0 : if ((!((steps()) == ((_o).steps())))) {
608 0 : return false;
609 : }
610 0 : if ((!((type()) == ((_o).type())))) {
611 0 : return false;
612 : }
613 0 : return true;
614 : }
615 :
616 0 : auto StepFunction::operator!=(const StepFunction& _o) const -> bool
617 : {
618 0 : return (!(operator==(_o)));
619 : }
620 :
621 0 : auto StepFunction::Init() -> void
622 : {
623 0 : }
624 :
625 0 : auto StepFunction::Assign(
626 : const int& _steps,
627 : const int& _type) -> void
628 : {
629 0 : steps_ = _steps;
630 0 : type_ = _type;
631 0 : }
632 :
633 : } // namespace layers
634 : } // namespace mozilla
635 :
636 : //-----------------------------------------------------------------------------
637 : // Method definitions for the IPDL type |struct FramesFunction|
638 : //
639 : namespace mozilla {
640 : namespace layers {
641 0 : MOZ_IMPLICIT FramesFunction::FramesFunction() :
642 0 : frames_()
643 : {
644 0 : Init();
645 0 : }
646 :
647 0 : FramesFunction::~FramesFunction()
648 : {
649 0 : }
650 :
651 0 : auto FramesFunction::operator==(const FramesFunction& _o) const -> bool
652 : {
653 0 : if ((!((frames()) == ((_o).frames())))) {
654 0 : return false;
655 : }
656 0 : return true;
657 : }
658 :
659 0 : auto FramesFunction::operator!=(const FramesFunction& _o) const -> bool
660 : {
661 0 : return (!(operator==(_o)));
662 : }
663 :
664 0 : auto FramesFunction::Init() -> void
665 : {
666 0 : }
667 :
668 0 : auto FramesFunction::Assign(const int& _frames) -> void
669 : {
670 0 : frames_ = _frames;
671 0 : }
672 :
673 : } // namespace layers
674 : } // namespace mozilla
675 :
676 : //-----------------------------------------------------------------------------
677 : // Method definitions for the IPDL type |union TimingFunction|
678 : //
679 : namespace mozilla {
680 : namespace layers {
681 0 : auto TimingFunction::MaybeDestroy(Type aNewType) -> bool
682 : {
683 0 : if ((mType) == (T__None)) {
684 0 : return true;
685 : }
686 0 : if ((mType) == (aNewType)) {
687 0 : return false;
688 : }
689 0 : switch (mType) {
690 : case Tnull_t:
691 : {
692 0 : (ptr_null_t())->~null_t__tdef();
693 0 : break;
694 : }
695 : case TCubicBezierFunction:
696 : {
697 0 : (ptr_CubicBezierFunction())->~CubicBezierFunction__tdef();
698 0 : break;
699 : }
700 : case TStepFunction:
701 : {
702 0 : (ptr_StepFunction())->~StepFunction__tdef();
703 0 : break;
704 : }
705 : case TFramesFunction:
706 : {
707 0 : (ptr_FramesFunction())->~FramesFunction__tdef();
708 0 : break;
709 : }
710 : default:
711 : {
712 0 : mozilla::ipc::LogicError("not reached");
713 0 : break;
714 : }
715 : }
716 0 : return true;
717 : }
718 :
719 0 : MOZ_IMPLICIT TimingFunction::TimingFunction(const null_t& aOther)
720 : {
721 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
722 0 : mType = Tnull_t;
723 0 : }
724 :
725 0 : MOZ_IMPLICIT TimingFunction::TimingFunction(const CubicBezierFunction& aOther)
726 : {
727 0 : new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction(aOther);
728 0 : mType = TCubicBezierFunction;
729 0 : }
730 :
731 0 : MOZ_IMPLICIT TimingFunction::TimingFunction(const StepFunction& aOther)
732 : {
733 0 : new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction(aOther);
734 0 : mType = TStepFunction;
735 0 : }
736 :
737 0 : MOZ_IMPLICIT TimingFunction::TimingFunction(const FramesFunction& aOther)
738 : {
739 0 : new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction(aOther);
740 0 : mType = TFramesFunction;
741 0 : }
742 :
743 0 : MOZ_IMPLICIT TimingFunction::TimingFunction(const TimingFunction& aOther)
744 : {
745 0 : (aOther).AssertSanity();
746 0 : switch ((aOther).type()) {
747 : case Tnull_t:
748 : {
749 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
750 0 : break;
751 : }
752 : case TCubicBezierFunction:
753 : {
754 0 : new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction((aOther).get_CubicBezierFunction());
755 0 : break;
756 : }
757 : case TStepFunction:
758 : {
759 0 : new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction((aOther).get_StepFunction());
760 0 : break;
761 : }
762 : case TFramesFunction:
763 : {
764 0 : new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction((aOther).get_FramesFunction());
765 0 : break;
766 : }
767 : case T__None:
768 : {
769 0 : break;
770 : }
771 : default:
772 : {
773 0 : mozilla::ipc::LogicError("unreached");
774 0 : return;
775 : }
776 : }
777 0 : mType = (aOther).type();
778 : }
779 :
780 0 : TimingFunction::~TimingFunction()
781 : {
782 0 : static_cast<void>(MaybeDestroy(T__None));
783 0 : }
784 :
785 0 : auto TimingFunction::operator=(const null_t& aRhs) -> TimingFunction&
786 : {
787 0 : if (MaybeDestroy(Tnull_t)) {
788 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
789 : }
790 0 : (*(ptr_null_t())) = aRhs;
791 0 : mType = Tnull_t;
792 0 : return (*(this));
793 : }
794 :
795 0 : auto TimingFunction::operator=(const CubicBezierFunction& aRhs) -> TimingFunction&
796 : {
797 0 : if (MaybeDestroy(TCubicBezierFunction)) {
798 0 : new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
799 : }
800 0 : (*(ptr_CubicBezierFunction())) = aRhs;
801 0 : mType = TCubicBezierFunction;
802 0 : return (*(this));
803 : }
804 :
805 0 : auto TimingFunction::operator=(const StepFunction& aRhs) -> TimingFunction&
806 : {
807 0 : if (MaybeDestroy(TStepFunction)) {
808 0 : new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
809 : }
810 0 : (*(ptr_StepFunction())) = aRhs;
811 0 : mType = TStepFunction;
812 0 : return (*(this));
813 : }
814 :
815 0 : auto TimingFunction::operator=(const FramesFunction& aRhs) -> TimingFunction&
816 : {
817 0 : if (MaybeDestroy(TFramesFunction)) {
818 0 : new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
819 : }
820 0 : (*(ptr_FramesFunction())) = aRhs;
821 0 : mType = TFramesFunction;
822 0 : return (*(this));
823 : }
824 :
825 0 : auto TimingFunction::operator=(const TimingFunction& aRhs) -> TimingFunction&
826 : {
827 0 : (aRhs).AssertSanity();
828 0 : Type t = (aRhs).type();
829 0 : switch (t) {
830 : case Tnull_t:
831 : {
832 0 : if (MaybeDestroy(t)) {
833 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
834 : }
835 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
836 0 : break;
837 : }
838 : case TCubicBezierFunction:
839 : {
840 0 : if (MaybeDestroy(t)) {
841 0 : new (mozilla::KnownNotNull, ptr_CubicBezierFunction()) CubicBezierFunction;
842 : }
843 0 : (*(ptr_CubicBezierFunction())) = (aRhs).get_CubicBezierFunction();
844 0 : break;
845 : }
846 : case TStepFunction:
847 : {
848 0 : if (MaybeDestroy(t)) {
849 0 : new (mozilla::KnownNotNull, ptr_StepFunction()) StepFunction;
850 : }
851 0 : (*(ptr_StepFunction())) = (aRhs).get_StepFunction();
852 0 : break;
853 : }
854 : case TFramesFunction:
855 : {
856 0 : if (MaybeDestroy(t)) {
857 0 : new (mozilla::KnownNotNull, ptr_FramesFunction()) FramesFunction;
858 : }
859 0 : (*(ptr_FramesFunction())) = (aRhs).get_FramesFunction();
860 0 : break;
861 : }
862 : case T__None:
863 : {
864 0 : static_cast<void>(MaybeDestroy(t));
865 0 : break;
866 : }
867 : default:
868 : {
869 0 : mozilla::ipc::LogicError("unreached");
870 0 : break;
871 : }
872 : }
873 0 : mType = t;
874 0 : return (*(this));
875 : }
876 :
877 0 : auto TimingFunction::operator==(const null_t& aRhs) const -> bool
878 : {
879 0 : return (get_null_t()) == (aRhs);
880 : }
881 :
882 0 : auto TimingFunction::operator==(const CubicBezierFunction& aRhs) const -> bool
883 : {
884 0 : return (get_CubicBezierFunction()) == (aRhs);
885 : }
886 :
887 0 : auto TimingFunction::operator==(const StepFunction& aRhs) const -> bool
888 : {
889 0 : return (get_StepFunction()) == (aRhs);
890 : }
891 :
892 0 : auto TimingFunction::operator==(const FramesFunction& aRhs) const -> bool
893 : {
894 0 : return (get_FramesFunction()) == (aRhs);
895 : }
896 :
897 0 : auto TimingFunction::operator==(const TimingFunction& aRhs) const -> bool
898 : {
899 0 : if ((type()) != ((aRhs).type())) {
900 0 : return false;
901 : }
902 :
903 0 : switch (type()) {
904 : case Tnull_t:
905 : {
906 0 : return (get_null_t()) == ((aRhs).get_null_t());
907 : }
908 : case TCubicBezierFunction:
909 : {
910 0 : return (get_CubicBezierFunction()) == ((aRhs).get_CubicBezierFunction());
911 : }
912 : case TStepFunction:
913 : {
914 0 : return (get_StepFunction()) == ((aRhs).get_StepFunction());
915 : }
916 : case TFramesFunction:
917 : {
918 0 : return (get_FramesFunction()) == ((aRhs).get_FramesFunction());
919 : }
920 : default:
921 : {
922 0 : mozilla::ipc::LogicError("unreached");
923 0 : return false;
924 : }
925 : }
926 : }
927 :
928 0 : auto TimingFunction::get(null_t* aOutValue) const -> void
929 : {
930 0 : (*(aOutValue)) = get_null_t();
931 0 : }
932 :
933 0 : auto TimingFunction::get(CubicBezierFunction* aOutValue) const -> void
934 : {
935 0 : (*(aOutValue)) = get_CubicBezierFunction();
936 0 : }
937 :
938 0 : auto TimingFunction::get(StepFunction* aOutValue) const -> void
939 : {
940 0 : (*(aOutValue)) = get_StepFunction();
941 0 : }
942 :
943 0 : auto TimingFunction::get(FramesFunction* aOutValue) const -> void
944 : {
945 0 : (*(aOutValue)) = get_FramesFunction();
946 0 : }
947 :
948 : } // namespace layers
949 : } // namespace mozilla
950 :
951 : //-----------------------------------------------------------------------------
952 : // Method definitions for the IPDL type |struct CSSAngle|
953 : //
954 : namespace mozilla {
955 : namespace layers {
956 0 : MOZ_IMPLICIT CSSAngle::CSSAngle() :
957 : value_(),
958 0 : unit_()
959 : {
960 0 : Init();
961 0 : }
962 :
963 0 : CSSAngle::~CSSAngle()
964 : {
965 0 : }
966 :
967 0 : auto CSSAngle::operator==(const CSSAngle& _o) const -> bool
968 : {
969 0 : if ((!((value()) == ((_o).value())))) {
970 0 : return false;
971 : }
972 0 : if ((!((unit()) == ((_o).unit())))) {
973 0 : return false;
974 : }
975 0 : return true;
976 : }
977 :
978 0 : auto CSSAngle::operator!=(const CSSAngle& _o) const -> bool
979 : {
980 0 : return (!(operator==(_o)));
981 : }
982 :
983 0 : auto CSSAngle::Init() -> void
984 : {
985 0 : }
986 :
987 0 : auto CSSAngle::Assign(
988 : const float& _value,
989 : const int& _unit) -> void
990 : {
991 0 : value_ = _value;
992 0 : unit_ = _unit;
993 0 : }
994 :
995 : } // namespace layers
996 : } // namespace mozilla
997 :
998 : //-----------------------------------------------------------------------------
999 : // Method definitions for the IPDL type |struct LayerColor|
1000 : //
1001 : namespace mozilla {
1002 : namespace layers {
1003 20 : MOZ_IMPLICIT LayerColor::LayerColor() :
1004 20 : value_()
1005 : {
1006 20 : Init();
1007 20 : }
1008 :
1009 24 : LayerColor::~LayerColor()
1010 : {
1011 24 : }
1012 :
1013 0 : auto LayerColor::operator==(const LayerColor& _o) const -> bool
1014 : {
1015 0 : if ((!((value()) == ((_o).value())))) {
1016 0 : return false;
1017 : }
1018 0 : return true;
1019 : }
1020 :
1021 0 : auto LayerColor::operator!=(const LayerColor& _o) const -> bool
1022 : {
1023 0 : return (!(operator==(_o)));
1024 : }
1025 :
1026 24 : auto LayerColor::Init() -> void
1027 : {
1028 24 : }
1029 :
1030 20 : auto LayerColor::Assign(const Color& _value) -> void
1031 : {
1032 20 : value_ = _value;
1033 20 : }
1034 :
1035 : } // namespace layers
1036 : } // namespace mozilla
1037 :
1038 : //-----------------------------------------------------------------------------
1039 : // Method definitions for the IPDL type |struct Perspective|
1040 : //
1041 : namespace mozilla {
1042 : namespace layers {
1043 0 : MOZ_IMPLICIT Perspective::Perspective() :
1044 0 : value_()
1045 : {
1046 0 : Init();
1047 0 : }
1048 :
1049 0 : Perspective::~Perspective()
1050 : {
1051 0 : }
1052 :
1053 0 : auto Perspective::operator==(const Perspective& _o) const -> bool
1054 : {
1055 0 : if ((!((value()) == ((_o).value())))) {
1056 0 : return false;
1057 : }
1058 0 : return true;
1059 : }
1060 :
1061 0 : auto Perspective::operator!=(const Perspective& _o) const -> bool
1062 : {
1063 0 : return (!(operator==(_o)));
1064 : }
1065 :
1066 0 : auto Perspective::Init() -> void
1067 : {
1068 0 : }
1069 :
1070 0 : auto Perspective::Assign(const float& _value) -> void
1071 : {
1072 0 : value_ = _value;
1073 0 : }
1074 :
1075 : } // namespace layers
1076 : } // namespace mozilla
1077 :
1078 : //-----------------------------------------------------------------------------
1079 : // Method definitions for the IPDL type |struct RotationX|
1080 : //
1081 : namespace mozilla {
1082 : namespace layers {
1083 0 : MOZ_IMPLICIT RotationX::RotationX()
1084 : {
1085 0 : Init();
1086 0 : }
1087 :
1088 0 : RotationX::~RotationX()
1089 : {
1090 0 : }
1091 :
1092 0 : auto RotationX::operator==(const RotationX& _o) const -> bool
1093 : {
1094 0 : if ((!((angle()) == ((_o).angle())))) {
1095 0 : return false;
1096 : }
1097 0 : return true;
1098 : }
1099 :
1100 0 : auto RotationX::operator!=(const RotationX& _o) const -> bool
1101 : {
1102 0 : return (!(operator==(_o)));
1103 : }
1104 :
1105 0 : auto RotationX::Init() -> void
1106 : {
1107 0 : }
1108 :
1109 0 : auto RotationX::Assign(const CSSAngle& _angle) -> void
1110 : {
1111 0 : angle_ = _angle;
1112 0 : }
1113 :
1114 : } // namespace layers
1115 : } // namespace mozilla
1116 :
1117 : //-----------------------------------------------------------------------------
1118 : // Method definitions for the IPDL type |struct RotationY|
1119 : //
1120 : namespace mozilla {
1121 : namespace layers {
1122 0 : MOZ_IMPLICIT RotationY::RotationY()
1123 : {
1124 0 : Init();
1125 0 : }
1126 :
1127 0 : RotationY::~RotationY()
1128 : {
1129 0 : }
1130 :
1131 0 : auto RotationY::operator==(const RotationY& _o) const -> bool
1132 : {
1133 0 : if ((!((angle()) == ((_o).angle())))) {
1134 0 : return false;
1135 : }
1136 0 : return true;
1137 : }
1138 :
1139 0 : auto RotationY::operator!=(const RotationY& _o) const -> bool
1140 : {
1141 0 : return (!(operator==(_o)));
1142 : }
1143 :
1144 0 : auto RotationY::Init() -> void
1145 : {
1146 0 : }
1147 :
1148 0 : auto RotationY::Assign(const CSSAngle& _angle) -> void
1149 : {
1150 0 : angle_ = _angle;
1151 0 : }
1152 :
1153 : } // namespace layers
1154 : } // namespace mozilla
1155 :
1156 : //-----------------------------------------------------------------------------
1157 : // Method definitions for the IPDL type |struct RotationZ|
1158 : //
1159 : namespace mozilla {
1160 : namespace layers {
1161 0 : MOZ_IMPLICIT RotationZ::RotationZ()
1162 : {
1163 0 : Init();
1164 0 : }
1165 :
1166 0 : RotationZ::~RotationZ()
1167 : {
1168 0 : }
1169 :
1170 0 : auto RotationZ::operator==(const RotationZ& _o) const -> bool
1171 : {
1172 0 : if ((!((angle()) == ((_o).angle())))) {
1173 0 : return false;
1174 : }
1175 0 : return true;
1176 : }
1177 :
1178 0 : auto RotationZ::operator!=(const RotationZ& _o) const -> bool
1179 : {
1180 0 : return (!(operator==(_o)));
1181 : }
1182 :
1183 0 : auto RotationZ::Init() -> void
1184 : {
1185 0 : }
1186 :
1187 0 : auto RotationZ::Assign(const CSSAngle& _angle) -> void
1188 : {
1189 0 : angle_ = _angle;
1190 0 : }
1191 :
1192 : } // namespace layers
1193 : } // namespace mozilla
1194 :
1195 : //-----------------------------------------------------------------------------
1196 : // Method definitions for the IPDL type |struct Rotation|
1197 : //
1198 : namespace mozilla {
1199 : namespace layers {
1200 0 : MOZ_IMPLICIT Rotation::Rotation()
1201 : {
1202 0 : Init();
1203 0 : }
1204 :
1205 0 : Rotation::~Rotation()
1206 : {
1207 0 : }
1208 :
1209 0 : auto Rotation::operator==(const Rotation& _o) const -> bool
1210 : {
1211 0 : if ((!((angle()) == ((_o).angle())))) {
1212 0 : return false;
1213 : }
1214 0 : return true;
1215 : }
1216 :
1217 0 : auto Rotation::operator!=(const Rotation& _o) const -> bool
1218 : {
1219 0 : return (!(operator==(_o)));
1220 : }
1221 :
1222 0 : auto Rotation::Init() -> void
1223 : {
1224 0 : }
1225 :
1226 0 : auto Rotation::Assign(const CSSAngle& _angle) -> void
1227 : {
1228 0 : angle_ = _angle;
1229 0 : }
1230 :
1231 : } // namespace layers
1232 : } // namespace mozilla
1233 :
1234 : //-----------------------------------------------------------------------------
1235 : // Method definitions for the IPDL type |struct Rotation3D|
1236 : //
1237 : namespace mozilla {
1238 : namespace layers {
1239 0 : MOZ_IMPLICIT Rotation3D::Rotation3D() :
1240 : x_(),
1241 : y_(),
1242 0 : z_()
1243 : {
1244 0 : Init();
1245 0 : }
1246 :
1247 0 : Rotation3D::~Rotation3D()
1248 : {
1249 0 : }
1250 :
1251 0 : auto Rotation3D::operator==(const Rotation3D& _o) const -> bool
1252 : {
1253 0 : if ((!((x()) == ((_o).x())))) {
1254 0 : return false;
1255 : }
1256 0 : if ((!((y()) == ((_o).y())))) {
1257 0 : return false;
1258 : }
1259 0 : if ((!((z()) == ((_o).z())))) {
1260 0 : return false;
1261 : }
1262 0 : if ((!((angle()) == ((_o).angle())))) {
1263 0 : return false;
1264 : }
1265 0 : return true;
1266 : }
1267 :
1268 0 : auto Rotation3D::operator!=(const Rotation3D& _o) const -> bool
1269 : {
1270 0 : return (!(operator==(_o)));
1271 : }
1272 :
1273 0 : auto Rotation3D::Init() -> void
1274 : {
1275 0 : }
1276 :
1277 0 : auto Rotation3D::Assign(
1278 : const float& _x,
1279 : const float& _y,
1280 : const float& _z,
1281 : const CSSAngle& _angle) -> void
1282 : {
1283 0 : x_ = _x;
1284 0 : y_ = _y;
1285 0 : z_ = _z;
1286 0 : angle_ = _angle;
1287 0 : }
1288 :
1289 : } // namespace layers
1290 : } // namespace mozilla
1291 :
1292 : //-----------------------------------------------------------------------------
1293 : // Method definitions for the IPDL type |struct Scale|
1294 : //
1295 : namespace mozilla {
1296 : namespace layers {
1297 0 : MOZ_IMPLICIT Scale::Scale() :
1298 : x_(),
1299 : y_(),
1300 0 : z_()
1301 : {
1302 0 : Init();
1303 0 : }
1304 :
1305 0 : Scale::~Scale()
1306 : {
1307 0 : }
1308 :
1309 0 : auto Scale::operator==(const Scale& _o) const -> bool
1310 : {
1311 0 : if ((!((x()) == ((_o).x())))) {
1312 0 : return false;
1313 : }
1314 0 : if ((!((y()) == ((_o).y())))) {
1315 0 : return false;
1316 : }
1317 0 : if ((!((z()) == ((_o).z())))) {
1318 0 : return false;
1319 : }
1320 0 : return true;
1321 : }
1322 :
1323 0 : auto Scale::operator!=(const Scale& _o) const -> bool
1324 : {
1325 0 : return (!(operator==(_o)));
1326 : }
1327 :
1328 0 : auto Scale::Init() -> void
1329 : {
1330 0 : }
1331 :
1332 0 : auto Scale::Assign(
1333 : const float& _x,
1334 : const float& _y,
1335 : const float& _z) -> void
1336 : {
1337 0 : x_ = _x;
1338 0 : y_ = _y;
1339 0 : z_ = _z;
1340 0 : }
1341 :
1342 : } // namespace layers
1343 : } // namespace mozilla
1344 :
1345 : //-----------------------------------------------------------------------------
1346 : // Method definitions for the IPDL type |struct Skew|
1347 : //
1348 : namespace mozilla {
1349 : namespace layers {
1350 0 : MOZ_IMPLICIT Skew::Skew()
1351 : {
1352 0 : Init();
1353 0 : }
1354 :
1355 0 : Skew::~Skew()
1356 : {
1357 0 : }
1358 :
1359 0 : auto Skew::operator==(const Skew& _o) const -> bool
1360 : {
1361 0 : if ((!((x()) == ((_o).x())))) {
1362 0 : return false;
1363 : }
1364 0 : if ((!((y()) == ((_o).y())))) {
1365 0 : return false;
1366 : }
1367 0 : return true;
1368 : }
1369 :
1370 0 : auto Skew::operator!=(const Skew& _o) const -> bool
1371 : {
1372 0 : return (!(operator==(_o)));
1373 : }
1374 :
1375 0 : auto Skew::Init() -> void
1376 : {
1377 0 : }
1378 :
1379 0 : auto Skew::Assign(
1380 : const CSSAngle& _x,
1381 : const CSSAngle& _y) -> void
1382 : {
1383 0 : x_ = _x;
1384 0 : y_ = _y;
1385 0 : }
1386 :
1387 : } // namespace layers
1388 : } // namespace mozilla
1389 :
1390 : //-----------------------------------------------------------------------------
1391 : // Method definitions for the IPDL type |struct SkewX|
1392 : //
1393 : namespace mozilla {
1394 : namespace layers {
1395 0 : MOZ_IMPLICIT SkewX::SkewX()
1396 : {
1397 0 : Init();
1398 0 : }
1399 :
1400 0 : SkewX::~SkewX()
1401 : {
1402 0 : }
1403 :
1404 0 : auto SkewX::operator==(const SkewX& _o) const -> bool
1405 : {
1406 0 : if ((!((x()) == ((_o).x())))) {
1407 0 : return false;
1408 : }
1409 0 : return true;
1410 : }
1411 :
1412 0 : auto SkewX::operator!=(const SkewX& _o) const -> bool
1413 : {
1414 0 : return (!(operator==(_o)));
1415 : }
1416 :
1417 0 : auto SkewX::Init() -> void
1418 : {
1419 0 : }
1420 :
1421 0 : auto SkewX::Assign(const CSSAngle& _x) -> void
1422 : {
1423 0 : x_ = _x;
1424 0 : }
1425 :
1426 : } // namespace layers
1427 : } // namespace mozilla
1428 :
1429 : //-----------------------------------------------------------------------------
1430 : // Method definitions for the IPDL type |struct SkewY|
1431 : //
1432 : namespace mozilla {
1433 : namespace layers {
1434 0 : MOZ_IMPLICIT SkewY::SkewY()
1435 : {
1436 0 : Init();
1437 0 : }
1438 :
1439 0 : SkewY::~SkewY()
1440 : {
1441 0 : }
1442 :
1443 0 : auto SkewY::operator==(const SkewY& _o) const -> bool
1444 : {
1445 0 : if ((!((y()) == ((_o).y())))) {
1446 0 : return false;
1447 : }
1448 0 : return true;
1449 : }
1450 :
1451 0 : auto SkewY::operator!=(const SkewY& _o) const -> bool
1452 : {
1453 0 : return (!(operator==(_o)));
1454 : }
1455 :
1456 0 : auto SkewY::Init() -> void
1457 : {
1458 0 : }
1459 :
1460 0 : auto SkewY::Assign(const CSSAngle& _y) -> void
1461 : {
1462 0 : y_ = _y;
1463 0 : }
1464 :
1465 : } // namespace layers
1466 : } // namespace mozilla
1467 :
1468 : //-----------------------------------------------------------------------------
1469 : // Method definitions for the IPDL type |struct TransformMatrix|
1470 : //
1471 : namespace mozilla {
1472 : namespace layers {
1473 0 : MOZ_IMPLICIT TransformMatrix::TransformMatrix() :
1474 0 : value_()
1475 : {
1476 0 : Init();
1477 0 : }
1478 :
1479 0 : TransformMatrix::~TransformMatrix()
1480 : {
1481 0 : }
1482 :
1483 0 : auto TransformMatrix::operator==(const TransformMatrix& _o) const -> bool
1484 : {
1485 0 : if ((!((value()) == ((_o).value())))) {
1486 0 : return false;
1487 : }
1488 0 : return true;
1489 : }
1490 :
1491 0 : auto TransformMatrix::operator!=(const TransformMatrix& _o) const -> bool
1492 : {
1493 0 : return (!(operator==(_o)));
1494 : }
1495 :
1496 0 : auto TransformMatrix::Init() -> void
1497 : {
1498 0 : }
1499 :
1500 0 : auto TransformMatrix::Assign(const Matrix4x4& _value) -> void
1501 : {
1502 0 : value_ = _value;
1503 0 : }
1504 :
1505 : } // namespace layers
1506 : } // namespace mozilla
1507 :
1508 : //-----------------------------------------------------------------------------
1509 : // Method definitions for the IPDL type |struct Translation|
1510 : //
1511 : namespace mozilla {
1512 : namespace layers {
1513 0 : MOZ_IMPLICIT Translation::Translation() :
1514 : x_(),
1515 : y_(),
1516 0 : z_()
1517 : {
1518 0 : Init();
1519 0 : }
1520 :
1521 0 : Translation::~Translation()
1522 : {
1523 0 : }
1524 :
1525 0 : auto Translation::operator==(const Translation& _o) const -> bool
1526 : {
1527 0 : if ((!((x()) == ((_o).x())))) {
1528 0 : return false;
1529 : }
1530 0 : if ((!((y()) == ((_o).y())))) {
1531 0 : return false;
1532 : }
1533 0 : if ((!((z()) == ((_o).z())))) {
1534 0 : return false;
1535 : }
1536 0 : return true;
1537 : }
1538 :
1539 0 : auto Translation::operator!=(const Translation& _o) const -> bool
1540 : {
1541 0 : return (!(operator==(_o)));
1542 : }
1543 :
1544 0 : auto Translation::Init() -> void
1545 : {
1546 0 : }
1547 :
1548 0 : auto Translation::Assign(
1549 : const float& _x,
1550 : const float& _y,
1551 : const float& _z) -> void
1552 : {
1553 0 : x_ = _x;
1554 0 : y_ = _y;
1555 0 : z_ = _z;
1556 0 : }
1557 :
1558 : } // namespace layers
1559 : } // namespace mozilla
1560 :
1561 : //-----------------------------------------------------------------------------
1562 : // Method definitions for the IPDL type |union TransformFunction|
1563 : //
1564 : namespace mozilla {
1565 : namespace layers {
1566 0 : auto TransformFunction::MaybeDestroy(Type aNewType) -> bool
1567 : {
1568 0 : if ((mType) == (T__None)) {
1569 0 : return true;
1570 : }
1571 0 : if ((mType) == (aNewType)) {
1572 0 : return false;
1573 : }
1574 0 : switch (mType) {
1575 : case TPerspective:
1576 : {
1577 0 : (ptr_Perspective())->~Perspective__tdef();
1578 0 : break;
1579 : }
1580 : case TRotationX:
1581 : {
1582 0 : (ptr_RotationX())->~RotationX__tdef();
1583 0 : break;
1584 : }
1585 : case TRotationY:
1586 : {
1587 0 : (ptr_RotationY())->~RotationY__tdef();
1588 0 : break;
1589 : }
1590 : case TRotationZ:
1591 : {
1592 0 : (ptr_RotationZ())->~RotationZ__tdef();
1593 0 : break;
1594 : }
1595 : case TRotation:
1596 : {
1597 0 : (ptr_Rotation())->~Rotation__tdef();
1598 0 : break;
1599 : }
1600 : case TRotation3D:
1601 : {
1602 0 : (ptr_Rotation3D())->~Rotation3D__tdef();
1603 0 : break;
1604 : }
1605 : case TScale:
1606 : {
1607 0 : (ptr_Scale())->~Scale__tdef();
1608 0 : break;
1609 : }
1610 : case TSkew:
1611 : {
1612 0 : (ptr_Skew())->~Skew__tdef();
1613 0 : break;
1614 : }
1615 : case TSkewX:
1616 : {
1617 0 : (ptr_SkewX())->~SkewX__tdef();
1618 0 : break;
1619 : }
1620 : case TSkewY:
1621 : {
1622 0 : (ptr_SkewY())->~SkewY__tdef();
1623 0 : break;
1624 : }
1625 : case TTranslation:
1626 : {
1627 0 : (ptr_Translation())->~Translation__tdef();
1628 0 : break;
1629 : }
1630 : case TTransformMatrix:
1631 : {
1632 0 : (ptr_TransformMatrix())->~TransformMatrix__tdef();
1633 0 : break;
1634 : }
1635 : default:
1636 : {
1637 0 : mozilla::ipc::LogicError("not reached");
1638 0 : break;
1639 : }
1640 : }
1641 0 : return true;
1642 : }
1643 :
1644 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Perspective& aOther)
1645 : {
1646 0 : new (mozilla::KnownNotNull, ptr_Perspective()) Perspective(aOther);
1647 0 : mType = TPerspective;
1648 0 : }
1649 :
1650 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationX& aOther)
1651 : {
1652 0 : new (mozilla::KnownNotNull, ptr_RotationX()) RotationX(aOther);
1653 0 : mType = TRotationX;
1654 0 : }
1655 :
1656 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationY& aOther)
1657 : {
1658 0 : new (mozilla::KnownNotNull, ptr_RotationY()) RotationY(aOther);
1659 0 : mType = TRotationY;
1660 0 : }
1661 :
1662 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const RotationZ& aOther)
1663 : {
1664 0 : new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ(aOther);
1665 0 : mType = TRotationZ;
1666 0 : }
1667 :
1668 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Rotation& aOther)
1669 : {
1670 0 : new (mozilla::KnownNotNull, ptr_Rotation()) Rotation(aOther);
1671 0 : mType = TRotation;
1672 0 : }
1673 :
1674 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Rotation3D& aOther)
1675 : {
1676 0 : new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D(aOther);
1677 0 : mType = TRotation3D;
1678 0 : }
1679 :
1680 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Scale& aOther)
1681 : {
1682 0 : new (mozilla::KnownNotNull, ptr_Scale()) Scale(aOther);
1683 0 : mType = TScale;
1684 0 : }
1685 :
1686 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Skew& aOther)
1687 : {
1688 0 : new (mozilla::KnownNotNull, ptr_Skew()) Skew(aOther);
1689 0 : mType = TSkew;
1690 0 : }
1691 :
1692 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const SkewX& aOther)
1693 : {
1694 0 : new (mozilla::KnownNotNull, ptr_SkewX()) SkewX(aOther);
1695 0 : mType = TSkewX;
1696 0 : }
1697 :
1698 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const SkewY& aOther)
1699 : {
1700 0 : new (mozilla::KnownNotNull, ptr_SkewY()) SkewY(aOther);
1701 0 : mType = TSkewY;
1702 0 : }
1703 :
1704 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const Translation& aOther)
1705 : {
1706 0 : new (mozilla::KnownNotNull, ptr_Translation()) Translation(aOther);
1707 0 : mType = TTranslation;
1708 0 : }
1709 :
1710 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const TransformMatrix& aOther)
1711 : {
1712 0 : new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix(aOther);
1713 0 : mType = TTransformMatrix;
1714 0 : }
1715 :
1716 0 : MOZ_IMPLICIT TransformFunction::TransformFunction(const TransformFunction& aOther)
1717 : {
1718 0 : (aOther).AssertSanity();
1719 0 : switch ((aOther).type()) {
1720 : case TPerspective:
1721 : {
1722 0 : new (mozilla::KnownNotNull, ptr_Perspective()) Perspective((aOther).get_Perspective());
1723 0 : break;
1724 : }
1725 : case TRotationX:
1726 : {
1727 0 : new (mozilla::KnownNotNull, ptr_RotationX()) RotationX((aOther).get_RotationX());
1728 0 : break;
1729 : }
1730 : case TRotationY:
1731 : {
1732 0 : new (mozilla::KnownNotNull, ptr_RotationY()) RotationY((aOther).get_RotationY());
1733 0 : break;
1734 : }
1735 : case TRotationZ:
1736 : {
1737 0 : new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ((aOther).get_RotationZ());
1738 0 : break;
1739 : }
1740 : case TRotation:
1741 : {
1742 0 : new (mozilla::KnownNotNull, ptr_Rotation()) Rotation((aOther).get_Rotation());
1743 0 : break;
1744 : }
1745 : case TRotation3D:
1746 : {
1747 0 : new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D((aOther).get_Rotation3D());
1748 0 : break;
1749 : }
1750 : case TScale:
1751 : {
1752 0 : new (mozilla::KnownNotNull, ptr_Scale()) Scale((aOther).get_Scale());
1753 0 : break;
1754 : }
1755 : case TSkew:
1756 : {
1757 0 : new (mozilla::KnownNotNull, ptr_Skew()) Skew((aOther).get_Skew());
1758 0 : break;
1759 : }
1760 : case TSkewX:
1761 : {
1762 0 : new (mozilla::KnownNotNull, ptr_SkewX()) SkewX((aOther).get_SkewX());
1763 0 : break;
1764 : }
1765 : case TSkewY:
1766 : {
1767 0 : new (mozilla::KnownNotNull, ptr_SkewY()) SkewY((aOther).get_SkewY());
1768 0 : break;
1769 : }
1770 : case TTranslation:
1771 : {
1772 0 : new (mozilla::KnownNotNull, ptr_Translation()) Translation((aOther).get_Translation());
1773 0 : break;
1774 : }
1775 : case TTransformMatrix:
1776 : {
1777 0 : new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix((aOther).get_TransformMatrix());
1778 0 : break;
1779 : }
1780 : case T__None:
1781 : {
1782 0 : break;
1783 : }
1784 : default:
1785 : {
1786 0 : mozilla::ipc::LogicError("unreached");
1787 0 : return;
1788 : }
1789 : }
1790 0 : mType = (aOther).type();
1791 : }
1792 :
1793 0 : TransformFunction::~TransformFunction()
1794 : {
1795 0 : static_cast<void>(MaybeDestroy(T__None));
1796 0 : }
1797 :
1798 0 : auto TransformFunction::operator=(const Perspective& aRhs) -> TransformFunction&
1799 : {
1800 0 : if (MaybeDestroy(TPerspective)) {
1801 0 : new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
1802 : }
1803 0 : (*(ptr_Perspective())) = aRhs;
1804 0 : mType = TPerspective;
1805 0 : return (*(this));
1806 : }
1807 :
1808 0 : auto TransformFunction::operator=(const RotationX& aRhs) -> TransformFunction&
1809 : {
1810 0 : if (MaybeDestroy(TRotationX)) {
1811 0 : new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
1812 : }
1813 0 : (*(ptr_RotationX())) = aRhs;
1814 0 : mType = TRotationX;
1815 0 : return (*(this));
1816 : }
1817 :
1818 0 : auto TransformFunction::operator=(const RotationY& aRhs) -> TransformFunction&
1819 : {
1820 0 : if (MaybeDestroy(TRotationY)) {
1821 0 : new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
1822 : }
1823 0 : (*(ptr_RotationY())) = aRhs;
1824 0 : mType = TRotationY;
1825 0 : return (*(this));
1826 : }
1827 :
1828 0 : auto TransformFunction::operator=(const RotationZ& aRhs) -> TransformFunction&
1829 : {
1830 0 : if (MaybeDestroy(TRotationZ)) {
1831 0 : new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
1832 : }
1833 0 : (*(ptr_RotationZ())) = aRhs;
1834 0 : mType = TRotationZ;
1835 0 : return (*(this));
1836 : }
1837 :
1838 0 : auto TransformFunction::operator=(const Rotation& aRhs) -> TransformFunction&
1839 : {
1840 0 : if (MaybeDestroy(TRotation)) {
1841 0 : new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
1842 : }
1843 0 : (*(ptr_Rotation())) = aRhs;
1844 0 : mType = TRotation;
1845 0 : return (*(this));
1846 : }
1847 :
1848 0 : auto TransformFunction::operator=(const Rotation3D& aRhs) -> TransformFunction&
1849 : {
1850 0 : if (MaybeDestroy(TRotation3D)) {
1851 0 : new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
1852 : }
1853 0 : (*(ptr_Rotation3D())) = aRhs;
1854 0 : mType = TRotation3D;
1855 0 : return (*(this));
1856 : }
1857 :
1858 0 : auto TransformFunction::operator=(const Scale& aRhs) -> TransformFunction&
1859 : {
1860 0 : if (MaybeDestroy(TScale)) {
1861 0 : new (mozilla::KnownNotNull, ptr_Scale()) Scale;
1862 : }
1863 0 : (*(ptr_Scale())) = aRhs;
1864 0 : mType = TScale;
1865 0 : return (*(this));
1866 : }
1867 :
1868 0 : auto TransformFunction::operator=(const Skew& aRhs) -> TransformFunction&
1869 : {
1870 0 : if (MaybeDestroy(TSkew)) {
1871 0 : new (mozilla::KnownNotNull, ptr_Skew()) Skew;
1872 : }
1873 0 : (*(ptr_Skew())) = aRhs;
1874 0 : mType = TSkew;
1875 0 : return (*(this));
1876 : }
1877 :
1878 0 : auto TransformFunction::operator=(const SkewX& aRhs) -> TransformFunction&
1879 : {
1880 0 : if (MaybeDestroy(TSkewX)) {
1881 0 : new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
1882 : }
1883 0 : (*(ptr_SkewX())) = aRhs;
1884 0 : mType = TSkewX;
1885 0 : return (*(this));
1886 : }
1887 :
1888 0 : auto TransformFunction::operator=(const SkewY& aRhs) -> TransformFunction&
1889 : {
1890 0 : if (MaybeDestroy(TSkewY)) {
1891 0 : new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
1892 : }
1893 0 : (*(ptr_SkewY())) = aRhs;
1894 0 : mType = TSkewY;
1895 0 : return (*(this));
1896 : }
1897 :
1898 0 : auto TransformFunction::operator=(const Translation& aRhs) -> TransformFunction&
1899 : {
1900 0 : if (MaybeDestroy(TTranslation)) {
1901 0 : new (mozilla::KnownNotNull, ptr_Translation()) Translation;
1902 : }
1903 0 : (*(ptr_Translation())) = aRhs;
1904 0 : mType = TTranslation;
1905 0 : return (*(this));
1906 : }
1907 :
1908 0 : auto TransformFunction::operator=(const TransformMatrix& aRhs) -> TransformFunction&
1909 : {
1910 0 : if (MaybeDestroy(TTransformMatrix)) {
1911 0 : new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
1912 : }
1913 0 : (*(ptr_TransformMatrix())) = aRhs;
1914 0 : mType = TTransformMatrix;
1915 0 : return (*(this));
1916 : }
1917 :
1918 0 : auto TransformFunction::operator=(const TransformFunction& aRhs) -> TransformFunction&
1919 : {
1920 0 : (aRhs).AssertSanity();
1921 0 : Type t = (aRhs).type();
1922 0 : switch (t) {
1923 : case TPerspective:
1924 : {
1925 0 : if (MaybeDestroy(t)) {
1926 0 : new (mozilla::KnownNotNull, ptr_Perspective()) Perspective;
1927 : }
1928 0 : (*(ptr_Perspective())) = (aRhs).get_Perspective();
1929 0 : break;
1930 : }
1931 : case TRotationX:
1932 : {
1933 0 : if (MaybeDestroy(t)) {
1934 0 : new (mozilla::KnownNotNull, ptr_RotationX()) RotationX;
1935 : }
1936 0 : (*(ptr_RotationX())) = (aRhs).get_RotationX();
1937 0 : break;
1938 : }
1939 : case TRotationY:
1940 : {
1941 0 : if (MaybeDestroy(t)) {
1942 0 : new (mozilla::KnownNotNull, ptr_RotationY()) RotationY;
1943 : }
1944 0 : (*(ptr_RotationY())) = (aRhs).get_RotationY();
1945 0 : break;
1946 : }
1947 : case TRotationZ:
1948 : {
1949 0 : if (MaybeDestroy(t)) {
1950 0 : new (mozilla::KnownNotNull, ptr_RotationZ()) RotationZ;
1951 : }
1952 0 : (*(ptr_RotationZ())) = (aRhs).get_RotationZ();
1953 0 : break;
1954 : }
1955 : case TRotation:
1956 : {
1957 0 : if (MaybeDestroy(t)) {
1958 0 : new (mozilla::KnownNotNull, ptr_Rotation()) Rotation;
1959 : }
1960 0 : (*(ptr_Rotation())) = (aRhs).get_Rotation();
1961 0 : break;
1962 : }
1963 : case TRotation3D:
1964 : {
1965 0 : if (MaybeDestroy(t)) {
1966 0 : new (mozilla::KnownNotNull, ptr_Rotation3D()) Rotation3D;
1967 : }
1968 0 : (*(ptr_Rotation3D())) = (aRhs).get_Rotation3D();
1969 0 : break;
1970 : }
1971 : case TScale:
1972 : {
1973 0 : if (MaybeDestroy(t)) {
1974 0 : new (mozilla::KnownNotNull, ptr_Scale()) Scale;
1975 : }
1976 0 : (*(ptr_Scale())) = (aRhs).get_Scale();
1977 0 : break;
1978 : }
1979 : case TSkew:
1980 : {
1981 0 : if (MaybeDestroy(t)) {
1982 0 : new (mozilla::KnownNotNull, ptr_Skew()) Skew;
1983 : }
1984 0 : (*(ptr_Skew())) = (aRhs).get_Skew();
1985 0 : break;
1986 : }
1987 : case TSkewX:
1988 : {
1989 0 : if (MaybeDestroy(t)) {
1990 0 : new (mozilla::KnownNotNull, ptr_SkewX()) SkewX;
1991 : }
1992 0 : (*(ptr_SkewX())) = (aRhs).get_SkewX();
1993 0 : break;
1994 : }
1995 : case TSkewY:
1996 : {
1997 0 : if (MaybeDestroy(t)) {
1998 0 : new (mozilla::KnownNotNull, ptr_SkewY()) SkewY;
1999 : }
2000 0 : (*(ptr_SkewY())) = (aRhs).get_SkewY();
2001 0 : break;
2002 : }
2003 : case TTranslation:
2004 : {
2005 0 : if (MaybeDestroy(t)) {
2006 0 : new (mozilla::KnownNotNull, ptr_Translation()) Translation;
2007 : }
2008 0 : (*(ptr_Translation())) = (aRhs).get_Translation();
2009 0 : break;
2010 : }
2011 : case TTransformMatrix:
2012 : {
2013 0 : if (MaybeDestroy(t)) {
2014 0 : new (mozilla::KnownNotNull, ptr_TransformMatrix()) TransformMatrix;
2015 : }
2016 0 : (*(ptr_TransformMatrix())) = (aRhs).get_TransformMatrix();
2017 0 : break;
2018 : }
2019 : case T__None:
2020 : {
2021 0 : static_cast<void>(MaybeDestroy(t));
2022 0 : break;
2023 : }
2024 : default:
2025 : {
2026 0 : mozilla::ipc::LogicError("unreached");
2027 0 : break;
2028 : }
2029 : }
2030 0 : mType = t;
2031 0 : return (*(this));
2032 : }
2033 :
2034 0 : auto TransformFunction::operator==(const Perspective& aRhs) const -> bool
2035 : {
2036 0 : return (get_Perspective()) == (aRhs);
2037 : }
2038 :
2039 0 : auto TransformFunction::operator==(const RotationX& aRhs) const -> bool
2040 : {
2041 0 : return (get_RotationX()) == (aRhs);
2042 : }
2043 :
2044 0 : auto TransformFunction::operator==(const RotationY& aRhs) const -> bool
2045 : {
2046 0 : return (get_RotationY()) == (aRhs);
2047 : }
2048 :
2049 0 : auto TransformFunction::operator==(const RotationZ& aRhs) const -> bool
2050 : {
2051 0 : return (get_RotationZ()) == (aRhs);
2052 : }
2053 :
2054 0 : auto TransformFunction::operator==(const Rotation& aRhs) const -> bool
2055 : {
2056 0 : return (get_Rotation()) == (aRhs);
2057 : }
2058 :
2059 0 : auto TransformFunction::operator==(const Rotation3D& aRhs) const -> bool
2060 : {
2061 0 : return (get_Rotation3D()) == (aRhs);
2062 : }
2063 :
2064 0 : auto TransformFunction::operator==(const Scale& aRhs) const -> bool
2065 : {
2066 0 : return (get_Scale()) == (aRhs);
2067 : }
2068 :
2069 0 : auto TransformFunction::operator==(const Skew& aRhs) const -> bool
2070 : {
2071 0 : return (get_Skew()) == (aRhs);
2072 : }
2073 :
2074 0 : auto TransformFunction::operator==(const SkewX& aRhs) const -> bool
2075 : {
2076 0 : return (get_SkewX()) == (aRhs);
2077 : }
2078 :
2079 0 : auto TransformFunction::operator==(const SkewY& aRhs) const -> bool
2080 : {
2081 0 : return (get_SkewY()) == (aRhs);
2082 : }
2083 :
2084 0 : auto TransformFunction::operator==(const Translation& aRhs) const -> bool
2085 : {
2086 0 : return (get_Translation()) == (aRhs);
2087 : }
2088 :
2089 0 : auto TransformFunction::operator==(const TransformMatrix& aRhs) const -> bool
2090 : {
2091 0 : return (get_TransformMatrix()) == (aRhs);
2092 : }
2093 :
2094 0 : auto TransformFunction::operator==(const TransformFunction& aRhs) const -> bool
2095 : {
2096 0 : if ((type()) != ((aRhs).type())) {
2097 0 : return false;
2098 : }
2099 :
2100 0 : switch (type()) {
2101 : case TPerspective:
2102 : {
2103 0 : return (get_Perspective()) == ((aRhs).get_Perspective());
2104 : }
2105 : case TRotationX:
2106 : {
2107 0 : return (get_RotationX()) == ((aRhs).get_RotationX());
2108 : }
2109 : case TRotationY:
2110 : {
2111 0 : return (get_RotationY()) == ((aRhs).get_RotationY());
2112 : }
2113 : case TRotationZ:
2114 : {
2115 0 : return (get_RotationZ()) == ((aRhs).get_RotationZ());
2116 : }
2117 : case TRotation:
2118 : {
2119 0 : return (get_Rotation()) == ((aRhs).get_Rotation());
2120 : }
2121 : case TRotation3D:
2122 : {
2123 0 : return (get_Rotation3D()) == ((aRhs).get_Rotation3D());
2124 : }
2125 : case TScale:
2126 : {
2127 0 : return (get_Scale()) == ((aRhs).get_Scale());
2128 : }
2129 : case TSkew:
2130 : {
2131 0 : return (get_Skew()) == ((aRhs).get_Skew());
2132 : }
2133 : case TSkewX:
2134 : {
2135 0 : return (get_SkewX()) == ((aRhs).get_SkewX());
2136 : }
2137 : case TSkewY:
2138 : {
2139 0 : return (get_SkewY()) == ((aRhs).get_SkewY());
2140 : }
2141 : case TTranslation:
2142 : {
2143 0 : return (get_Translation()) == ((aRhs).get_Translation());
2144 : }
2145 : case TTransformMatrix:
2146 : {
2147 0 : return (get_TransformMatrix()) == ((aRhs).get_TransformMatrix());
2148 : }
2149 : default:
2150 : {
2151 0 : mozilla::ipc::LogicError("unreached");
2152 0 : return false;
2153 : }
2154 : }
2155 : }
2156 :
2157 0 : auto TransformFunction::get(Perspective* aOutValue) const -> void
2158 : {
2159 0 : (*(aOutValue)) = get_Perspective();
2160 0 : }
2161 :
2162 0 : auto TransformFunction::get(RotationX* aOutValue) const -> void
2163 : {
2164 0 : (*(aOutValue)) = get_RotationX();
2165 0 : }
2166 :
2167 0 : auto TransformFunction::get(RotationY* aOutValue) const -> void
2168 : {
2169 0 : (*(aOutValue)) = get_RotationY();
2170 0 : }
2171 :
2172 0 : auto TransformFunction::get(RotationZ* aOutValue) const -> void
2173 : {
2174 0 : (*(aOutValue)) = get_RotationZ();
2175 0 : }
2176 :
2177 0 : auto TransformFunction::get(Rotation* aOutValue) const -> void
2178 : {
2179 0 : (*(aOutValue)) = get_Rotation();
2180 0 : }
2181 :
2182 0 : auto TransformFunction::get(Rotation3D* aOutValue) const -> void
2183 : {
2184 0 : (*(aOutValue)) = get_Rotation3D();
2185 0 : }
2186 :
2187 0 : auto TransformFunction::get(Scale* aOutValue) const -> void
2188 : {
2189 0 : (*(aOutValue)) = get_Scale();
2190 0 : }
2191 :
2192 0 : auto TransformFunction::get(Skew* aOutValue) const -> void
2193 : {
2194 0 : (*(aOutValue)) = get_Skew();
2195 0 : }
2196 :
2197 0 : auto TransformFunction::get(SkewX* aOutValue) const -> void
2198 : {
2199 0 : (*(aOutValue)) = get_SkewX();
2200 0 : }
2201 :
2202 0 : auto TransformFunction::get(SkewY* aOutValue) const -> void
2203 : {
2204 0 : (*(aOutValue)) = get_SkewY();
2205 0 : }
2206 :
2207 0 : auto TransformFunction::get(Translation* aOutValue) const -> void
2208 : {
2209 0 : (*(aOutValue)) = get_Translation();
2210 0 : }
2211 :
2212 0 : auto TransformFunction::get(TransformMatrix* aOutValue) const -> void
2213 : {
2214 0 : (*(aOutValue)) = get_TransformMatrix();
2215 0 : }
2216 :
2217 : } // namespace layers
2218 : } // namespace mozilla
2219 :
2220 : //-----------------------------------------------------------------------------
2221 : // Method definitions for the IPDL type |union MaybeTimeDuration|
2222 : //
2223 : namespace mozilla {
2224 : namespace layers {
2225 0 : auto MaybeTimeDuration::MaybeDestroy(Type aNewType) -> bool
2226 : {
2227 0 : if ((mType) == (T__None)) {
2228 0 : return true;
2229 : }
2230 0 : if ((mType) == (aNewType)) {
2231 0 : return false;
2232 : }
2233 0 : switch (mType) {
2234 : case Tnull_t:
2235 : {
2236 0 : (ptr_null_t())->~null_t__tdef();
2237 0 : break;
2238 : }
2239 : case TTimeDuration:
2240 : {
2241 0 : (ptr_TimeDuration())->~TimeDuration__tdef();
2242 0 : break;
2243 : }
2244 : default:
2245 : {
2246 0 : mozilla::ipc::LogicError("not reached");
2247 0 : break;
2248 : }
2249 : }
2250 0 : return true;
2251 : }
2252 :
2253 0 : MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(const null_t& aOther)
2254 : {
2255 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
2256 0 : mType = Tnull_t;
2257 0 : }
2258 :
2259 0 : MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(const TimeDuration& aOther)
2260 : {
2261 0 : new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration(aOther);
2262 0 : mType = TTimeDuration;
2263 0 : }
2264 :
2265 0 : MOZ_IMPLICIT MaybeTimeDuration::MaybeTimeDuration(const MaybeTimeDuration& aOther)
2266 : {
2267 0 : (aOther).AssertSanity();
2268 0 : switch ((aOther).type()) {
2269 : case Tnull_t:
2270 : {
2271 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
2272 0 : break;
2273 : }
2274 : case TTimeDuration:
2275 : {
2276 0 : new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration((aOther).get_TimeDuration());
2277 0 : break;
2278 : }
2279 : case T__None:
2280 : {
2281 0 : break;
2282 : }
2283 : default:
2284 : {
2285 0 : mozilla::ipc::LogicError("unreached");
2286 0 : return;
2287 : }
2288 : }
2289 0 : mType = (aOther).type();
2290 : }
2291 :
2292 0 : MaybeTimeDuration::~MaybeTimeDuration()
2293 : {
2294 0 : static_cast<void>(MaybeDestroy(T__None));
2295 0 : }
2296 :
2297 0 : auto MaybeTimeDuration::operator=(const null_t& aRhs) -> MaybeTimeDuration&
2298 : {
2299 0 : if (MaybeDestroy(Tnull_t)) {
2300 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2301 : }
2302 0 : (*(ptr_null_t())) = aRhs;
2303 0 : mType = Tnull_t;
2304 0 : return (*(this));
2305 : }
2306 :
2307 0 : auto MaybeTimeDuration::operator=(const TimeDuration& aRhs) -> MaybeTimeDuration&
2308 : {
2309 0 : if (MaybeDestroy(TTimeDuration)) {
2310 0 : new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration;
2311 : }
2312 0 : (*(ptr_TimeDuration())) = aRhs;
2313 0 : mType = TTimeDuration;
2314 0 : return (*(this));
2315 : }
2316 :
2317 0 : auto MaybeTimeDuration::operator=(const MaybeTimeDuration& aRhs) -> MaybeTimeDuration&
2318 : {
2319 0 : (aRhs).AssertSanity();
2320 0 : Type t = (aRhs).type();
2321 0 : switch (t) {
2322 : case Tnull_t:
2323 : {
2324 0 : if (MaybeDestroy(t)) {
2325 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2326 : }
2327 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
2328 0 : break;
2329 : }
2330 : case TTimeDuration:
2331 : {
2332 0 : if (MaybeDestroy(t)) {
2333 0 : new (mozilla::KnownNotNull, ptr_TimeDuration()) TimeDuration;
2334 : }
2335 0 : (*(ptr_TimeDuration())) = (aRhs).get_TimeDuration();
2336 0 : break;
2337 : }
2338 : case T__None:
2339 : {
2340 0 : static_cast<void>(MaybeDestroy(t));
2341 0 : break;
2342 : }
2343 : default:
2344 : {
2345 0 : mozilla::ipc::LogicError("unreached");
2346 0 : break;
2347 : }
2348 : }
2349 0 : mType = t;
2350 0 : return (*(this));
2351 : }
2352 :
2353 0 : auto MaybeTimeDuration::operator==(const null_t& aRhs) const -> bool
2354 : {
2355 0 : return (get_null_t()) == (aRhs);
2356 : }
2357 :
2358 0 : auto MaybeTimeDuration::operator==(const TimeDuration& aRhs) const -> bool
2359 : {
2360 0 : return (get_TimeDuration()) == (aRhs);
2361 : }
2362 :
2363 0 : auto MaybeTimeDuration::operator==(const MaybeTimeDuration& aRhs) const -> bool
2364 : {
2365 0 : if ((type()) != ((aRhs).type())) {
2366 0 : return false;
2367 : }
2368 :
2369 0 : switch (type()) {
2370 : case Tnull_t:
2371 : {
2372 0 : return (get_null_t()) == ((aRhs).get_null_t());
2373 : }
2374 : case TTimeDuration:
2375 : {
2376 0 : return (get_TimeDuration()) == ((aRhs).get_TimeDuration());
2377 : }
2378 : default:
2379 : {
2380 0 : mozilla::ipc::LogicError("unreached");
2381 0 : return false;
2382 : }
2383 : }
2384 : }
2385 :
2386 0 : auto MaybeTimeDuration::get(null_t* aOutValue) const -> void
2387 : {
2388 0 : (*(aOutValue)) = get_null_t();
2389 0 : }
2390 :
2391 0 : auto MaybeTimeDuration::get(TimeDuration* aOutValue) const -> void
2392 : {
2393 0 : (*(aOutValue)) = get_TimeDuration();
2394 0 : }
2395 :
2396 : } // namespace layers
2397 : } // namespace mozilla
2398 :
2399 : //-----------------------------------------------------------------------------
2400 : // Method definitions for the IPDL type |union Animatable|
2401 : //
2402 : namespace mozilla {
2403 : namespace layers {
2404 0 : auto Animatable::MaybeDestroy(Type aNewType) -> bool
2405 : {
2406 0 : if ((mType) == (T__None)) {
2407 0 : return true;
2408 : }
2409 0 : if ((mType) == (aNewType)) {
2410 0 : return false;
2411 : }
2412 0 : switch (mType) {
2413 : case Tnull_t:
2414 : {
2415 0 : (ptr_null_t())->~null_t__tdef();
2416 0 : break;
2417 : }
2418 : case Tfloat:
2419 : {
2420 0 : (ptr_float())->~float__tdef();
2421 0 : break;
2422 : }
2423 : case TArrayOfTransformFunction:
2424 : {
2425 0 : (ptr_ArrayOfTransformFunction())->~ArrayOfTransformFunction__tdef();
2426 0 : break;
2427 : }
2428 : default:
2429 : {
2430 0 : mozilla::ipc::LogicError("not reached");
2431 0 : break;
2432 : }
2433 : }
2434 0 : return true;
2435 : }
2436 :
2437 0 : MOZ_IMPLICIT Animatable::Animatable(const null_t& aOther)
2438 : {
2439 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
2440 0 : mType = Tnull_t;
2441 0 : }
2442 :
2443 0 : MOZ_IMPLICIT Animatable::Animatable(const float& aOther)
2444 : {
2445 0 : new (mozilla::KnownNotNull, ptr_float()) float(aOther);
2446 0 : mType = Tfloat;
2447 0 : }
2448 :
2449 0 : MOZ_IMPLICIT Animatable::Animatable(const nsTArray<TransformFunction>& aOther)
2450 : {
2451 0 : new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>(aOther);
2452 0 : mType = TArrayOfTransformFunction;
2453 0 : }
2454 :
2455 0 : MOZ_IMPLICIT Animatable::Animatable(const Animatable& aOther)
2456 : {
2457 0 : (aOther).AssertSanity();
2458 0 : switch ((aOther).type()) {
2459 : case Tnull_t:
2460 : {
2461 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
2462 0 : break;
2463 : }
2464 : case Tfloat:
2465 : {
2466 0 : new (mozilla::KnownNotNull, ptr_float()) float((aOther).get_float());
2467 0 : break;
2468 : }
2469 : case TArrayOfTransformFunction:
2470 : {
2471 0 : new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>((aOther).get_ArrayOfTransformFunction());
2472 0 : break;
2473 : }
2474 : case T__None:
2475 : {
2476 0 : break;
2477 : }
2478 : default:
2479 : {
2480 0 : mozilla::ipc::LogicError("unreached");
2481 0 : return;
2482 : }
2483 : }
2484 0 : mType = (aOther).type();
2485 : }
2486 :
2487 0 : Animatable::~Animatable()
2488 : {
2489 0 : static_cast<void>(MaybeDestroy(T__None));
2490 0 : }
2491 :
2492 0 : auto Animatable::operator=(const null_t& aRhs) -> Animatable&
2493 : {
2494 0 : if (MaybeDestroy(Tnull_t)) {
2495 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2496 : }
2497 0 : (*(ptr_null_t())) = aRhs;
2498 0 : mType = Tnull_t;
2499 0 : return (*(this));
2500 : }
2501 :
2502 0 : auto Animatable::operator=(const float& aRhs) -> Animatable&
2503 : {
2504 0 : if (MaybeDestroy(Tfloat)) {
2505 0 : new (mozilla::KnownNotNull, ptr_float()) float;
2506 : }
2507 0 : (*(ptr_float())) = aRhs;
2508 0 : mType = Tfloat;
2509 0 : return (*(this));
2510 : }
2511 :
2512 0 : auto Animatable::operator=(const nsTArray<TransformFunction>& aRhs) -> Animatable&
2513 : {
2514 0 : if (MaybeDestroy(TArrayOfTransformFunction)) {
2515 0 : new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>;
2516 : }
2517 0 : (*(ptr_ArrayOfTransformFunction())) = aRhs;
2518 0 : mType = TArrayOfTransformFunction;
2519 0 : return (*(this));
2520 : }
2521 :
2522 0 : auto Animatable::operator=(const Animatable& aRhs) -> Animatable&
2523 : {
2524 0 : (aRhs).AssertSanity();
2525 0 : Type t = (aRhs).type();
2526 0 : switch (t) {
2527 : case Tnull_t:
2528 : {
2529 0 : if (MaybeDestroy(t)) {
2530 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2531 : }
2532 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
2533 0 : break;
2534 : }
2535 : case Tfloat:
2536 : {
2537 0 : if (MaybeDestroy(t)) {
2538 0 : new (mozilla::KnownNotNull, ptr_float()) float;
2539 : }
2540 0 : (*(ptr_float())) = (aRhs).get_float();
2541 0 : break;
2542 : }
2543 : case TArrayOfTransformFunction:
2544 : {
2545 0 : if (MaybeDestroy(t)) {
2546 0 : new (mozilla::KnownNotNull, ptr_ArrayOfTransformFunction()) nsTArray<TransformFunction>;
2547 : }
2548 0 : (*(ptr_ArrayOfTransformFunction())) = (aRhs).get_ArrayOfTransformFunction();
2549 0 : break;
2550 : }
2551 : case T__None:
2552 : {
2553 0 : static_cast<void>(MaybeDestroy(t));
2554 0 : break;
2555 : }
2556 : default:
2557 : {
2558 0 : mozilla::ipc::LogicError("unreached");
2559 0 : break;
2560 : }
2561 : }
2562 0 : mType = t;
2563 0 : return (*(this));
2564 : }
2565 :
2566 0 : auto Animatable::operator==(const null_t& aRhs) const -> bool
2567 : {
2568 0 : return (get_null_t()) == (aRhs);
2569 : }
2570 :
2571 0 : auto Animatable::operator==(const float& aRhs) const -> bool
2572 : {
2573 0 : return (get_float()) == (aRhs);
2574 : }
2575 :
2576 0 : auto Animatable::operator==(const nsTArray<TransformFunction>& aRhs) const -> bool
2577 : {
2578 0 : return (get_ArrayOfTransformFunction()) == (aRhs);
2579 : }
2580 :
2581 0 : auto Animatable::operator==(const Animatable& aRhs) const -> bool
2582 : {
2583 0 : if ((type()) != ((aRhs).type())) {
2584 0 : return false;
2585 : }
2586 :
2587 0 : switch (type()) {
2588 : case Tnull_t:
2589 : {
2590 0 : return (get_null_t()) == ((aRhs).get_null_t());
2591 : }
2592 : case Tfloat:
2593 : {
2594 0 : return (get_float()) == ((aRhs).get_float());
2595 : }
2596 : case TArrayOfTransformFunction:
2597 : {
2598 0 : return (get_ArrayOfTransformFunction()) == ((aRhs).get_ArrayOfTransformFunction());
2599 : }
2600 : default:
2601 : {
2602 0 : mozilla::ipc::LogicError("unreached");
2603 0 : return false;
2604 : }
2605 : }
2606 : }
2607 :
2608 0 : auto Animatable::get(null_t* aOutValue) const -> void
2609 : {
2610 0 : (*(aOutValue)) = get_null_t();
2611 0 : }
2612 :
2613 0 : auto Animatable::get(float* aOutValue) const -> void
2614 : {
2615 0 : (*(aOutValue)) = get_float();
2616 0 : }
2617 :
2618 0 : auto Animatable::get(nsTArray<TransformFunction>* aOutValue) const -> void
2619 : {
2620 0 : (*(aOutValue)) = get_ArrayOfTransformFunction();
2621 0 : }
2622 :
2623 : } // namespace layers
2624 : } // namespace mozilla
2625 :
2626 : //-----------------------------------------------------------------------------
2627 : // Method definitions for the IPDL type |struct AnimationSegment|
2628 : //
2629 : namespace mozilla {
2630 : namespace layers {
2631 0 : MOZ_IMPLICIT AnimationSegment::AnimationSegment() :
2632 : startPortion_(),
2633 : endPortion_(),
2634 : startComposite_(),
2635 0 : endComposite_()
2636 : {
2637 0 : Init();
2638 0 : }
2639 :
2640 0 : AnimationSegment::~AnimationSegment()
2641 : {
2642 0 : }
2643 :
2644 0 : auto AnimationSegment::operator==(const AnimationSegment& _o) const -> bool
2645 : {
2646 0 : if ((!((startState()) == ((_o).startState())))) {
2647 0 : return false;
2648 : }
2649 0 : if ((!((endState()) == ((_o).endState())))) {
2650 0 : return false;
2651 : }
2652 0 : if ((!((startPortion()) == ((_o).startPortion())))) {
2653 0 : return false;
2654 : }
2655 0 : if ((!((endPortion()) == ((_o).endPortion())))) {
2656 0 : return false;
2657 : }
2658 0 : if ((!((startComposite()) == ((_o).startComposite())))) {
2659 0 : return false;
2660 : }
2661 0 : if ((!((endComposite()) == ((_o).endComposite())))) {
2662 0 : return false;
2663 : }
2664 0 : if ((!((sampleFn()) == ((_o).sampleFn())))) {
2665 0 : return false;
2666 : }
2667 0 : return true;
2668 : }
2669 :
2670 0 : auto AnimationSegment::operator!=(const AnimationSegment& _o) const -> bool
2671 : {
2672 0 : return (!(operator==(_o)));
2673 : }
2674 :
2675 0 : auto AnimationSegment::Init() -> void
2676 : {
2677 0 : }
2678 :
2679 0 : auto AnimationSegment::Assign(
2680 : const Animatable& _startState,
2681 : const Animatable& _endState,
2682 : const float& _startPortion,
2683 : const float& _endPortion,
2684 : const uint8_t& _startComposite,
2685 : const uint8_t& _endComposite,
2686 : const TimingFunction& _sampleFn) -> void
2687 : {
2688 0 : startState_ = _startState;
2689 0 : endState_ = _endState;
2690 0 : startPortion_ = _startPortion;
2691 0 : endPortion_ = _endPortion;
2692 0 : startComposite_ = _startComposite;
2693 0 : endComposite_ = _endComposite;
2694 0 : sampleFn_ = _sampleFn;
2695 0 : }
2696 :
2697 : } // namespace layers
2698 : } // namespace mozilla
2699 :
2700 : //-----------------------------------------------------------------------------
2701 : // Method definitions for the IPDL type |struct TransformData|
2702 : //
2703 : namespace mozilla {
2704 : namespace layers {
2705 0 : MOZ_IMPLICIT TransformData::TransformData() :
2706 : origin_(),
2707 : transformOrigin_(),
2708 : bounds_(),
2709 : appUnitsPerDevPixel_(),
2710 : inheritedXScale_(),
2711 : inheritedYScale_(),
2712 0 : hasPerspectiveParent_()
2713 : {
2714 0 : Init();
2715 0 : }
2716 :
2717 0 : TransformData::~TransformData()
2718 : {
2719 0 : }
2720 :
2721 0 : auto TransformData::operator==(const TransformData& _o) const -> bool
2722 : {
2723 0 : if ((!((origin()) == ((_o).origin())))) {
2724 0 : return false;
2725 : }
2726 0 : if ((!((transformOrigin()) == ((_o).transformOrigin())))) {
2727 0 : return false;
2728 : }
2729 0 : if ((!((bounds()) == ((_o).bounds())))) {
2730 0 : return false;
2731 : }
2732 0 : if ((!((appUnitsPerDevPixel()) == ((_o).appUnitsPerDevPixel())))) {
2733 0 : return false;
2734 : }
2735 0 : if ((!((inheritedXScale()) == ((_o).inheritedXScale())))) {
2736 0 : return false;
2737 : }
2738 0 : if ((!((inheritedYScale()) == ((_o).inheritedYScale())))) {
2739 0 : return false;
2740 : }
2741 0 : if ((!((hasPerspectiveParent()) == ((_o).hasPerspectiveParent())))) {
2742 0 : return false;
2743 : }
2744 0 : return true;
2745 : }
2746 :
2747 0 : auto TransformData::operator!=(const TransformData& _o) const -> bool
2748 : {
2749 0 : return (!(operator==(_o)));
2750 : }
2751 :
2752 0 : auto TransformData::Init() -> void
2753 : {
2754 0 : }
2755 :
2756 0 : auto TransformData::Assign(
2757 : const nsPoint& _origin,
2758 : const Point3D& _transformOrigin,
2759 : const nsRect& _bounds,
2760 : const int32_t& _appUnitsPerDevPixel,
2761 : const float& _inheritedXScale,
2762 : const float& _inheritedYScale,
2763 : const bool& _hasPerspectiveParent) -> void
2764 : {
2765 0 : origin_ = _origin;
2766 0 : transformOrigin_ = _transformOrigin;
2767 0 : bounds_ = _bounds;
2768 0 : appUnitsPerDevPixel_ = _appUnitsPerDevPixel;
2769 0 : inheritedXScale_ = _inheritedXScale;
2770 0 : inheritedYScale_ = _inheritedYScale;
2771 0 : hasPerspectiveParent_ = _hasPerspectiveParent;
2772 0 : }
2773 :
2774 : } // namespace layers
2775 : } // namespace mozilla
2776 :
2777 : //-----------------------------------------------------------------------------
2778 : // Method definitions for the IPDL type |union AnimationData|
2779 : //
2780 : namespace mozilla {
2781 : namespace layers {
2782 0 : auto AnimationData::MaybeDestroy(Type aNewType) -> bool
2783 : {
2784 0 : if ((mType) == (T__None)) {
2785 0 : return true;
2786 : }
2787 0 : if ((mType) == (aNewType)) {
2788 0 : return false;
2789 : }
2790 0 : switch (mType) {
2791 : case Tnull_t:
2792 : {
2793 0 : (ptr_null_t())->~null_t__tdef();
2794 0 : break;
2795 : }
2796 : case TTransformData:
2797 : {
2798 0 : (ptr_TransformData())->~TransformData__tdef();
2799 0 : break;
2800 : }
2801 : default:
2802 : {
2803 0 : mozilla::ipc::LogicError("not reached");
2804 0 : break;
2805 : }
2806 : }
2807 0 : return true;
2808 : }
2809 :
2810 0 : MOZ_IMPLICIT AnimationData::AnimationData(const null_t& aOther)
2811 : {
2812 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
2813 0 : mType = Tnull_t;
2814 0 : }
2815 :
2816 0 : MOZ_IMPLICIT AnimationData::AnimationData(const TransformData& aOther)
2817 : {
2818 0 : new (mozilla::KnownNotNull, ptr_TransformData()) TransformData(aOther);
2819 0 : mType = TTransformData;
2820 0 : }
2821 :
2822 0 : MOZ_IMPLICIT AnimationData::AnimationData(const AnimationData& aOther)
2823 : {
2824 0 : (aOther).AssertSanity();
2825 0 : switch ((aOther).type()) {
2826 : case Tnull_t:
2827 : {
2828 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
2829 0 : break;
2830 : }
2831 : case TTransformData:
2832 : {
2833 0 : new (mozilla::KnownNotNull, ptr_TransformData()) TransformData((aOther).get_TransformData());
2834 0 : break;
2835 : }
2836 : case T__None:
2837 : {
2838 0 : break;
2839 : }
2840 : default:
2841 : {
2842 0 : mozilla::ipc::LogicError("unreached");
2843 0 : return;
2844 : }
2845 : }
2846 0 : mType = (aOther).type();
2847 : }
2848 :
2849 0 : AnimationData::~AnimationData()
2850 : {
2851 0 : static_cast<void>(MaybeDestroy(T__None));
2852 0 : }
2853 :
2854 0 : auto AnimationData::operator=(const null_t& aRhs) -> AnimationData&
2855 : {
2856 0 : if (MaybeDestroy(Tnull_t)) {
2857 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2858 : }
2859 0 : (*(ptr_null_t())) = aRhs;
2860 0 : mType = Tnull_t;
2861 0 : return (*(this));
2862 : }
2863 :
2864 0 : auto AnimationData::operator=(const TransformData& aRhs) -> AnimationData&
2865 : {
2866 0 : if (MaybeDestroy(TTransformData)) {
2867 0 : new (mozilla::KnownNotNull, ptr_TransformData()) TransformData;
2868 : }
2869 0 : (*(ptr_TransformData())) = aRhs;
2870 0 : mType = TTransformData;
2871 0 : return (*(this));
2872 : }
2873 :
2874 0 : auto AnimationData::operator=(const AnimationData& aRhs) -> AnimationData&
2875 : {
2876 0 : (aRhs).AssertSanity();
2877 0 : Type t = (aRhs).type();
2878 0 : switch (t) {
2879 : case Tnull_t:
2880 : {
2881 0 : if (MaybeDestroy(t)) {
2882 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
2883 : }
2884 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
2885 0 : break;
2886 : }
2887 : case TTransformData:
2888 : {
2889 0 : if (MaybeDestroy(t)) {
2890 0 : new (mozilla::KnownNotNull, ptr_TransformData()) TransformData;
2891 : }
2892 0 : (*(ptr_TransformData())) = (aRhs).get_TransformData();
2893 0 : break;
2894 : }
2895 : case T__None:
2896 : {
2897 0 : static_cast<void>(MaybeDestroy(t));
2898 0 : break;
2899 : }
2900 : default:
2901 : {
2902 0 : mozilla::ipc::LogicError("unreached");
2903 0 : break;
2904 : }
2905 : }
2906 0 : mType = t;
2907 0 : return (*(this));
2908 : }
2909 :
2910 0 : auto AnimationData::operator==(const null_t& aRhs) const -> bool
2911 : {
2912 0 : return (get_null_t()) == (aRhs);
2913 : }
2914 :
2915 0 : auto AnimationData::operator==(const TransformData& aRhs) const -> bool
2916 : {
2917 0 : return (get_TransformData()) == (aRhs);
2918 : }
2919 :
2920 0 : auto AnimationData::operator==(const AnimationData& aRhs) const -> bool
2921 : {
2922 0 : if ((type()) != ((aRhs).type())) {
2923 0 : return false;
2924 : }
2925 :
2926 0 : switch (type()) {
2927 : case Tnull_t:
2928 : {
2929 0 : return (get_null_t()) == ((aRhs).get_null_t());
2930 : }
2931 : case TTransformData:
2932 : {
2933 0 : return (get_TransformData()) == ((aRhs).get_TransformData());
2934 : }
2935 : default:
2936 : {
2937 0 : mozilla::ipc::LogicError("unreached");
2938 0 : return false;
2939 : }
2940 : }
2941 : }
2942 :
2943 0 : auto AnimationData::get(null_t* aOutValue) const -> void
2944 : {
2945 0 : (*(aOutValue)) = get_null_t();
2946 0 : }
2947 :
2948 0 : auto AnimationData::get(TransformData* aOutValue) const -> void
2949 : {
2950 0 : (*(aOutValue)) = get_TransformData();
2951 0 : }
2952 :
2953 : } // namespace layers
2954 : } // namespace mozilla
2955 :
2956 : //-----------------------------------------------------------------------------
2957 : // Method definitions for the IPDL type |struct Animation|
2958 : //
2959 : namespace mozilla {
2960 : namespace layers {
2961 0 : MOZ_IMPLICIT Animation::Animation() :
2962 : originTime_(),
2963 : delay_(),
2964 : endDelay_(),
2965 : holdTime_(),
2966 : duration_(),
2967 : iterations_(),
2968 : iterationStart_(),
2969 : direction_(),
2970 : fillMode_(),
2971 : property_(),
2972 : playbackRate_(),
2973 : iterationComposite_(),
2974 0 : isNotPlaying_()
2975 : {
2976 0 : Init();
2977 0 : }
2978 :
2979 0 : Animation::~Animation()
2980 : {
2981 0 : }
2982 :
2983 0 : auto Animation::operator==(const Animation& _o) const -> bool
2984 : {
2985 0 : if ((!((originTime()) == ((_o).originTime())))) {
2986 0 : return false;
2987 : }
2988 0 : if ((!((startTime()) == ((_o).startTime())))) {
2989 0 : return false;
2990 : }
2991 0 : if ((!((delay()) == ((_o).delay())))) {
2992 0 : return false;
2993 : }
2994 0 : if ((!((endDelay()) == ((_o).endDelay())))) {
2995 0 : return false;
2996 : }
2997 0 : if ((!((holdTime()) == ((_o).holdTime())))) {
2998 0 : return false;
2999 : }
3000 0 : if ((!((duration()) == ((_o).duration())))) {
3001 0 : return false;
3002 : }
3003 0 : if ((!((segments()) == ((_o).segments())))) {
3004 0 : return false;
3005 : }
3006 0 : if ((!((iterations()) == ((_o).iterations())))) {
3007 0 : return false;
3008 : }
3009 0 : if ((!((iterationStart()) == ((_o).iterationStart())))) {
3010 0 : return false;
3011 : }
3012 0 : if ((!((direction()) == ((_o).direction())))) {
3013 0 : return false;
3014 : }
3015 0 : if ((!((fillMode()) == ((_o).fillMode())))) {
3016 0 : return false;
3017 : }
3018 0 : if ((!((property()) == ((_o).property())))) {
3019 0 : return false;
3020 : }
3021 0 : if ((!((data()) == ((_o).data())))) {
3022 0 : return false;
3023 : }
3024 0 : if ((!((playbackRate()) == ((_o).playbackRate())))) {
3025 0 : return false;
3026 : }
3027 0 : if ((!((easingFunction()) == ((_o).easingFunction())))) {
3028 0 : return false;
3029 : }
3030 0 : if ((!((iterationComposite()) == ((_o).iterationComposite())))) {
3031 0 : return false;
3032 : }
3033 0 : if ((!((isNotPlaying()) == ((_o).isNotPlaying())))) {
3034 0 : return false;
3035 : }
3036 0 : if ((!((baseStyle()) == ((_o).baseStyle())))) {
3037 0 : return false;
3038 : }
3039 0 : return true;
3040 : }
3041 :
3042 0 : auto Animation::operator!=(const Animation& _o) const -> bool
3043 : {
3044 0 : return (!(operator==(_o)));
3045 : }
3046 :
3047 0 : auto Animation::Init() -> void
3048 : {
3049 0 : }
3050 :
3051 0 : auto Animation::Assign(
3052 : const TimeStamp& _originTime,
3053 : const MaybeTimeDuration& _startTime,
3054 : const TimeDuration& _delay,
3055 : const TimeDuration& _endDelay,
3056 : const TimeDuration& _holdTime,
3057 : const TimeDuration& _duration,
3058 : const nsTArray<AnimationSegment>& _segments,
3059 : const float& _iterations,
3060 : const float& _iterationStart,
3061 : const uint8_t& _direction,
3062 : const uint8_t& _fillMode,
3063 : const nsCSSPropertyID& _property,
3064 : const AnimationData& _data,
3065 : const float& _playbackRate,
3066 : const TimingFunction& _easingFunction,
3067 : const uint8_t& _iterationComposite,
3068 : const bool& _isNotPlaying,
3069 : const Animatable& _baseStyle) -> void
3070 : {
3071 0 : originTime_ = _originTime;
3072 0 : startTime_ = _startTime;
3073 0 : delay_ = _delay;
3074 0 : endDelay_ = _endDelay;
3075 0 : holdTime_ = _holdTime;
3076 0 : duration_ = _duration;
3077 0 : segments_ = _segments;
3078 0 : iterations_ = _iterations;
3079 0 : iterationStart_ = _iterationStart;
3080 0 : direction_ = _direction;
3081 0 : fillMode_ = _fillMode;
3082 0 : property_ = _property;
3083 0 : data_ = _data;
3084 0 : playbackRate_ = _playbackRate;
3085 0 : easingFunction_ = _easingFunction;
3086 0 : iterationComposite_ = _iterationComposite;
3087 0 : isNotPlaying_ = _isNotPlaying;
3088 0 : baseStyle_ = _baseStyle;
3089 0 : }
3090 :
3091 : } // namespace layers
3092 : } // namespace mozilla
3093 :
3094 : //-----------------------------------------------------------------------------
3095 : // Method definitions for the IPDL type |struct CompositorAnimations|
3096 : //
3097 : namespace mozilla {
3098 : namespace layers {
3099 372 : MOZ_IMPLICIT CompositorAnimations::CompositorAnimations() :
3100 372 : id_()
3101 : {
3102 372 : Init();
3103 372 : }
3104 :
3105 372 : CompositorAnimations::~CompositorAnimations()
3106 : {
3107 372 : }
3108 :
3109 0 : auto CompositorAnimations::operator==(const CompositorAnimations& _o) const -> bool
3110 : {
3111 0 : if ((!((animations()) == ((_o).animations())))) {
3112 0 : return false;
3113 : }
3114 0 : if ((!((id()) == ((_o).id())))) {
3115 0 : return false;
3116 : }
3117 0 : return true;
3118 : }
3119 :
3120 0 : auto CompositorAnimations::operator!=(const CompositorAnimations& _o) const -> bool
3121 : {
3122 0 : return (!(operator==(_o)));
3123 : }
3124 :
3125 372 : auto CompositorAnimations::Init() -> void
3126 : {
3127 372 : }
3128 :
3129 124 : auto CompositorAnimations::Assign(
3130 : const nsTArray<Animation>& _animations,
3131 : const uint64_t& _id) -> void
3132 : {
3133 124 : animations_ = _animations;
3134 124 : id_ = _id;
3135 124 : }
3136 :
3137 : } // namespace layers
3138 : } // namespace mozilla
3139 :
3140 : //-----------------------------------------------------------------------------
3141 : // Method definitions for the IPDL type |struct CommonLayerAttributes|
3142 : //
3143 : namespace mozilla {
3144 : namespace layers {
3145 372 : MOZ_IMPLICIT CommonLayerAttributes::CommonLayerAttributes() :
3146 : visibleRegion_(),
3147 : eventRegions_(),
3148 : useClipRect_(),
3149 : clipRect_(),
3150 : maskLayer_(),
3151 : invalidRegion_(),
3152 372 : displayListLog_()
3153 : {
3154 372 : Init();
3155 372 : }
3156 :
3157 372 : CommonLayerAttributes::~CommonLayerAttributes()
3158 : {
3159 372 : }
3160 :
3161 0 : auto CommonLayerAttributes::operator==(const CommonLayerAttributes& _o) const -> bool
3162 : {
3163 0 : if ((!((visibleRegion()) == ((_o).visibleRegion())))) {
3164 0 : return false;
3165 : }
3166 0 : if ((!((eventRegions()) == ((_o).eventRegions())))) {
3167 0 : return false;
3168 : }
3169 0 : if ((!((useClipRect()) == ((_o).useClipRect())))) {
3170 0 : return false;
3171 : }
3172 0 : if ((!((clipRect()) == ((_o).clipRect())))) {
3173 0 : return false;
3174 : }
3175 0 : if ((!((maskLayer()) == ((_o).maskLayer())))) {
3176 0 : return false;
3177 : }
3178 0 : if ((!((ancestorMaskLayers()) == ((_o).ancestorMaskLayers())))) {
3179 0 : return false;
3180 : }
3181 0 : if ((!((compositorAnimations()) == ((_o).compositorAnimations())))) {
3182 0 : return false;
3183 : }
3184 0 : if ((!((invalidRegion()) == ((_o).invalidRegion())))) {
3185 0 : return false;
3186 : }
3187 0 : if ((!((scrollMetadata()) == ((_o).scrollMetadata())))) {
3188 0 : return false;
3189 : }
3190 0 : if ((!((displayListLog()) == ((_o).displayListLog())))) {
3191 0 : return false;
3192 : }
3193 0 : return true;
3194 : }
3195 :
3196 0 : auto CommonLayerAttributes::operator!=(const CommonLayerAttributes& _o) const -> bool
3197 : {
3198 0 : return (!(operator==(_o)));
3199 : }
3200 :
3201 372 : auto CommonLayerAttributes::Init() -> void
3202 : {
3203 372 : }
3204 :
3205 124 : auto CommonLayerAttributes::Assign(
3206 : const LayerIntRegion& _visibleRegion,
3207 : const EventRegions& _eventRegions,
3208 : const bool& _useClipRect,
3209 : const ParentLayerIntRect& _clipRect,
3210 : const LayerHandle& _maskLayer,
3211 : const nsTArray<LayerHandle>& _ancestorMaskLayers,
3212 : const CompositorAnimations& _compositorAnimations,
3213 : const nsIntRegion& _invalidRegion,
3214 : const nsTArray<ScrollMetadata>& _scrollMetadata,
3215 : const nsCString& _displayListLog) -> void
3216 : {
3217 124 : visibleRegion_ = _visibleRegion;
3218 124 : eventRegions_ = _eventRegions;
3219 124 : useClipRect_ = _useClipRect;
3220 124 : clipRect_ = _clipRect;
3221 124 : maskLayer_ = _maskLayer;
3222 124 : ancestorMaskLayers_ = _ancestorMaskLayers;
3223 124 : compositorAnimations_ = _compositorAnimations;
3224 124 : invalidRegion_ = _invalidRegion;
3225 124 : scrollMetadata_ = _scrollMetadata;
3226 124 : displayListLog_ = _displayListLog;
3227 124 : }
3228 :
3229 : } // namespace layers
3230 : } // namespace mozilla
3231 :
3232 : //-----------------------------------------------------------------------------
3233 : // Method definitions for the IPDL type |struct PaintedLayerAttributes|
3234 : //
3235 : namespace mozilla {
3236 : namespace layers {
3237 212 : MOZ_IMPLICIT PaintedLayerAttributes::PaintedLayerAttributes() :
3238 212 : validRegion_()
3239 : {
3240 212 : Init();
3241 212 : }
3242 :
3243 265 : PaintedLayerAttributes::~PaintedLayerAttributes()
3244 : {
3245 265 : }
3246 :
3247 0 : auto PaintedLayerAttributes::operator==(const PaintedLayerAttributes& _o) const -> bool
3248 : {
3249 0 : if ((!((validRegion()) == ((_o).validRegion())))) {
3250 0 : return false;
3251 : }
3252 0 : return true;
3253 : }
3254 :
3255 0 : auto PaintedLayerAttributes::operator!=(const PaintedLayerAttributes& _o) const -> bool
3256 : {
3257 0 : return (!(operator==(_o)));
3258 : }
3259 :
3260 265 : auto PaintedLayerAttributes::Init() -> void
3261 : {
3262 265 : }
3263 :
3264 212 : auto PaintedLayerAttributes::Assign(const nsIntRegion& _validRegion) -> void
3265 : {
3266 212 : validRegion_ = _validRegion;
3267 212 : }
3268 :
3269 : } // namespace layers
3270 : } // namespace mozilla
3271 :
3272 : //-----------------------------------------------------------------------------
3273 : // Method definitions for the IPDL type |struct ContainerLayerAttributes|
3274 : //
3275 : namespace mozilla {
3276 : namespace layers {
3277 172 : MOZ_IMPLICIT ContainerLayerAttributes::ContainerLayerAttributes() :
3278 : preXScale_(),
3279 : preYScale_(),
3280 : inheritedXScale_(),
3281 : inheritedYScale_(),
3282 : presShellResolution_(),
3283 : scaleToResolution_(),
3284 172 : eventRegionsOverride_()
3285 : {
3286 172 : Init();
3287 172 : }
3288 :
3289 215 : ContainerLayerAttributes::~ContainerLayerAttributes()
3290 : {
3291 215 : }
3292 :
3293 0 : auto ContainerLayerAttributes::operator==(const ContainerLayerAttributes& _o) const -> bool
3294 : {
3295 0 : if ((!((preXScale()) == ((_o).preXScale())))) {
3296 0 : return false;
3297 : }
3298 0 : if ((!((preYScale()) == ((_o).preYScale())))) {
3299 0 : return false;
3300 : }
3301 0 : if ((!((inheritedXScale()) == ((_o).inheritedXScale())))) {
3302 0 : return false;
3303 : }
3304 0 : if ((!((inheritedYScale()) == ((_o).inheritedYScale())))) {
3305 0 : return false;
3306 : }
3307 0 : if ((!((presShellResolution()) == ((_o).presShellResolution())))) {
3308 0 : return false;
3309 : }
3310 0 : if ((!((scaleToResolution()) == ((_o).scaleToResolution())))) {
3311 0 : return false;
3312 : }
3313 0 : if ((!((eventRegionsOverride()) == ((_o).eventRegionsOverride())))) {
3314 0 : return false;
3315 : }
3316 0 : return true;
3317 : }
3318 :
3319 0 : auto ContainerLayerAttributes::operator!=(const ContainerLayerAttributes& _o) const -> bool
3320 : {
3321 0 : return (!(operator==(_o)));
3322 : }
3323 :
3324 215 : auto ContainerLayerAttributes::Init() -> void
3325 : {
3326 215 : }
3327 :
3328 172 : auto ContainerLayerAttributes::Assign(
3329 : const float& _preXScale,
3330 : const float& _preYScale,
3331 : const float& _inheritedXScale,
3332 : const float& _inheritedYScale,
3333 : const float& _presShellResolution,
3334 : const bool& _scaleToResolution,
3335 : const EventRegionsOverride& _eventRegionsOverride) -> void
3336 : {
3337 172 : preXScale_ = _preXScale;
3338 172 : preYScale_ = _preYScale;
3339 172 : inheritedXScale_ = _inheritedXScale;
3340 172 : inheritedYScale_ = _inheritedYScale;
3341 172 : presShellResolution_ = _presShellResolution;
3342 172 : scaleToResolution_ = _scaleToResolution;
3343 172 : eventRegionsOverride_ = _eventRegionsOverride;
3344 172 : }
3345 :
3346 : } // namespace layers
3347 : } // namespace mozilla
3348 :
3349 : //-----------------------------------------------------------------------------
3350 : // Method definitions for the IPDL type |struct GlyphArray|
3351 : //
3352 : namespace mozilla {
3353 : namespace layers {
3354 0 : MOZ_IMPLICIT GlyphArray::GlyphArray()
3355 : {
3356 0 : Init();
3357 0 : }
3358 :
3359 0 : GlyphArray::~GlyphArray()
3360 : {
3361 0 : }
3362 :
3363 0 : auto GlyphArray::operator==(const GlyphArray& _o) const -> bool
3364 : {
3365 0 : if ((!((color()) == ((_o).color())))) {
3366 0 : return false;
3367 : }
3368 0 : if ((!((glyphs()) == ((_o).glyphs())))) {
3369 0 : return false;
3370 : }
3371 0 : return true;
3372 : }
3373 :
3374 0 : auto GlyphArray::operator!=(const GlyphArray& _o) const -> bool
3375 : {
3376 0 : return (!(operator==(_o)));
3377 : }
3378 :
3379 0 : auto GlyphArray::Init() -> void
3380 : {
3381 0 : }
3382 :
3383 0 : auto GlyphArray::Assign(
3384 : const LayerColor& _color,
3385 : const nsTArray<Glyph>& _glyphs) -> void
3386 : {
3387 0 : color_ = _color;
3388 0 : glyphs_ = _glyphs;
3389 0 : }
3390 :
3391 : } // namespace layers
3392 : } // namespace mozilla
3393 :
3394 : //-----------------------------------------------------------------------------
3395 : // Method definitions for the IPDL type |struct TextLayerAttributes|
3396 : //
3397 : namespace mozilla {
3398 : namespace layers {
3399 0 : MOZ_IMPLICIT TextLayerAttributes::TextLayerAttributes() :
3400 : bounds_(),
3401 0 : scaledFont_()
3402 : {
3403 0 : Init();
3404 0 : }
3405 :
3406 0 : TextLayerAttributes::~TextLayerAttributes()
3407 : {
3408 0 : }
3409 :
3410 0 : auto TextLayerAttributes::operator==(const TextLayerAttributes& _o) const -> bool
3411 : {
3412 0 : if ((!((bounds()) == ((_o).bounds())))) {
3413 0 : return false;
3414 : }
3415 0 : if ((!((glyphs()) == ((_o).glyphs())))) {
3416 0 : return false;
3417 : }
3418 0 : if ((!((scaledFont()) == ((_o).scaledFont())))) {
3419 0 : return false;
3420 : }
3421 0 : return true;
3422 : }
3423 :
3424 0 : auto TextLayerAttributes::operator!=(const TextLayerAttributes& _o) const -> bool
3425 : {
3426 0 : return (!(operator==(_o)));
3427 : }
3428 :
3429 0 : auto TextLayerAttributes::Init() -> void
3430 : {
3431 0 : }
3432 :
3433 0 : auto TextLayerAttributes::Assign(
3434 : const IntRect& _bounds,
3435 : const nsTArray<GlyphArray>& _glyphs,
3436 : const uintptr_t& _scaledFont) -> void
3437 : {
3438 0 : bounds_ = _bounds;
3439 0 : glyphs_ = _glyphs;
3440 0 : scaledFont_ = _scaledFont;
3441 0 : }
3442 :
3443 : } // namespace layers
3444 : } // namespace mozilla
3445 :
3446 : //-----------------------------------------------------------------------------
3447 : // Method definitions for the IPDL type |struct ColorLayerAttributes|
3448 : //
3449 : namespace mozilla {
3450 : namespace layers {
3451 16 : MOZ_IMPLICIT ColorLayerAttributes::ColorLayerAttributes() :
3452 16 : bounds_()
3453 : {
3454 16 : Init();
3455 16 : }
3456 :
3457 20 : ColorLayerAttributes::~ColorLayerAttributes()
3458 : {
3459 20 : }
3460 :
3461 0 : auto ColorLayerAttributes::operator==(const ColorLayerAttributes& _o) const -> bool
3462 : {
3463 0 : if ((!((color()) == ((_o).color())))) {
3464 0 : return false;
3465 : }
3466 0 : if ((!((bounds()) == ((_o).bounds())))) {
3467 0 : return false;
3468 : }
3469 0 : return true;
3470 : }
3471 :
3472 0 : auto ColorLayerAttributes::operator!=(const ColorLayerAttributes& _o) const -> bool
3473 : {
3474 0 : return (!(operator==(_o)));
3475 : }
3476 :
3477 20 : auto ColorLayerAttributes::Init() -> void
3478 : {
3479 20 : }
3480 :
3481 16 : auto ColorLayerAttributes::Assign(
3482 : const LayerColor& _color,
3483 : const IntRect& _bounds) -> void
3484 : {
3485 16 : color_ = _color;
3486 16 : bounds_ = _bounds;
3487 16 : }
3488 :
3489 : } // namespace layers
3490 : } // namespace mozilla
3491 :
3492 : //-----------------------------------------------------------------------------
3493 : // Method definitions for the IPDL type |struct CanvasLayerAttributes|
3494 : //
3495 : namespace mozilla {
3496 : namespace layers {
3497 0 : MOZ_IMPLICIT CanvasLayerAttributes::CanvasLayerAttributes() :
3498 : samplingFilter_(),
3499 0 : bounds_()
3500 : {
3501 0 : Init();
3502 0 : }
3503 :
3504 0 : CanvasLayerAttributes::~CanvasLayerAttributes()
3505 : {
3506 0 : }
3507 :
3508 0 : auto CanvasLayerAttributes::operator==(const CanvasLayerAttributes& _o) const -> bool
3509 : {
3510 0 : if ((!((samplingFilter()) == ((_o).samplingFilter())))) {
3511 0 : return false;
3512 : }
3513 0 : if ((!((bounds()) == ((_o).bounds())))) {
3514 0 : return false;
3515 : }
3516 0 : return true;
3517 : }
3518 :
3519 0 : auto CanvasLayerAttributes::operator!=(const CanvasLayerAttributes& _o) const -> bool
3520 : {
3521 0 : return (!(operator==(_o)));
3522 : }
3523 :
3524 0 : auto CanvasLayerAttributes::Init() -> void
3525 : {
3526 0 : }
3527 :
3528 0 : auto CanvasLayerAttributes::Assign(
3529 : const SamplingFilter& _samplingFilter,
3530 : const IntRect& _bounds) -> void
3531 : {
3532 0 : samplingFilter_ = _samplingFilter;
3533 0 : bounds_ = _bounds;
3534 0 : }
3535 :
3536 : } // namespace layers
3537 : } // namespace mozilla
3538 :
3539 : //-----------------------------------------------------------------------------
3540 : // Method definitions for the IPDL type |struct RefLayerAttributes|
3541 : //
3542 : namespace mozilla {
3543 : namespace layers {
3544 96 : MOZ_IMPLICIT RefLayerAttributes::RefLayerAttributes() :
3545 : id_(),
3546 96 : eventRegionsOverride_()
3547 : {
3548 96 : Init();
3549 96 : }
3550 :
3551 120 : RefLayerAttributes::~RefLayerAttributes()
3552 : {
3553 120 : }
3554 :
3555 0 : auto RefLayerAttributes::operator==(const RefLayerAttributes& _o) const -> bool
3556 : {
3557 0 : if ((!((id()) == ((_o).id())))) {
3558 0 : return false;
3559 : }
3560 0 : if ((!((eventRegionsOverride()) == ((_o).eventRegionsOverride())))) {
3561 0 : return false;
3562 : }
3563 0 : return true;
3564 : }
3565 :
3566 0 : auto RefLayerAttributes::operator!=(const RefLayerAttributes& _o) const -> bool
3567 : {
3568 0 : return (!(operator==(_o)));
3569 : }
3570 :
3571 120 : auto RefLayerAttributes::Init() -> void
3572 : {
3573 120 : }
3574 :
3575 96 : auto RefLayerAttributes::Assign(
3576 : const uint64_t& _id,
3577 : const EventRegionsOverride& _eventRegionsOverride) -> void
3578 : {
3579 96 : id_ = _id;
3580 96 : eventRegionsOverride_ = _eventRegionsOverride;
3581 96 : }
3582 :
3583 : } // namespace layers
3584 : } // namespace mozilla
3585 :
3586 : //-----------------------------------------------------------------------------
3587 : // Method definitions for the IPDL type |struct ImageLayerAttributes|
3588 : //
3589 : namespace mozilla {
3590 : namespace layers {
3591 0 : MOZ_IMPLICIT ImageLayerAttributes::ImageLayerAttributes() :
3592 : samplingFilter_(),
3593 : scaleToSize_(),
3594 0 : scaleMode_()
3595 : {
3596 0 : Init();
3597 0 : }
3598 :
3599 0 : ImageLayerAttributes::~ImageLayerAttributes()
3600 : {
3601 0 : }
3602 :
3603 0 : auto ImageLayerAttributes::operator==(const ImageLayerAttributes& _o) const -> bool
3604 : {
3605 0 : if ((!((samplingFilter()) == ((_o).samplingFilter())))) {
3606 0 : return false;
3607 : }
3608 0 : if ((!((scaleToSize()) == ((_o).scaleToSize())))) {
3609 0 : return false;
3610 : }
3611 0 : if ((!((scaleMode()) == ((_o).scaleMode())))) {
3612 0 : return false;
3613 : }
3614 0 : return true;
3615 : }
3616 :
3617 0 : auto ImageLayerAttributes::operator!=(const ImageLayerAttributes& _o) const -> bool
3618 : {
3619 0 : return (!(operator==(_o)));
3620 : }
3621 :
3622 0 : auto ImageLayerAttributes::Init() -> void
3623 : {
3624 0 : }
3625 :
3626 0 : auto ImageLayerAttributes::Assign(
3627 : const SamplingFilter& _samplingFilter,
3628 : const IntSize& _scaleToSize,
3629 : const ScaleMode& _scaleMode) -> void
3630 : {
3631 0 : samplingFilter_ = _samplingFilter;
3632 0 : scaleToSize_ = _scaleToSize;
3633 0 : scaleMode_ = _scaleMode;
3634 0 : }
3635 :
3636 : } // namespace layers
3637 : } // namespace mozilla
3638 :
3639 : //-----------------------------------------------------------------------------
3640 : // Method definitions for the IPDL type |struct BorderLayerAttributes|
3641 : //
3642 : namespace mozilla {
3643 : namespace layers {
3644 0 : MOZ_IMPLICIT BorderLayerAttributes::BorderLayerAttributes() :
3645 : rect_(),
3646 : colors_(),
3647 : corners_(),
3648 0 : widths_()
3649 : {
3650 0 : Init();
3651 0 : }
3652 :
3653 0 : BorderLayerAttributes::~BorderLayerAttributes()
3654 : {
3655 0 : }
3656 :
3657 0 : auto BorderLayerAttributes::operator==(const BorderLayerAttributes& _o) const -> bool
3658 : {
3659 0 : if ((!((rect()) == ((_o).rect())))) {
3660 0 : return false;
3661 : }
3662 0 : if ((!((colors()) == ((_o).colors())))) {
3663 0 : return false;
3664 : }
3665 0 : if ((!((corners()) == ((_o).corners())))) {
3666 0 : return false;
3667 : }
3668 0 : if ((!((widths()) == ((_o).widths())))) {
3669 0 : return false;
3670 : }
3671 0 : return true;
3672 : }
3673 :
3674 0 : auto BorderLayerAttributes::operator!=(const BorderLayerAttributes& _o) const -> bool
3675 : {
3676 0 : return (!(operator==(_o)));
3677 : }
3678 :
3679 0 : auto BorderLayerAttributes::Init() -> void
3680 : {
3681 0 : }
3682 :
3683 0 : auto BorderLayerAttributes::Assign(
3684 : const LayerRect& _rect,
3685 : const BorderColors& _colors,
3686 : const BorderCorners& _corners,
3687 : const BorderWidths& _widths) -> void
3688 : {
3689 0 : rect_ = _rect;
3690 0 : colors_ = _colors;
3691 0 : corners_ = _corners;
3692 0 : widths_ = _widths;
3693 0 : }
3694 :
3695 : } // namespace layers
3696 : } // namespace mozilla
3697 :
3698 : //-----------------------------------------------------------------------------
3699 : // Method definitions for the IPDL type |union SpecificLayerAttributes|
3700 : //
3701 : namespace mozilla {
3702 : namespace layers {
3703 868 : auto SpecificLayerAttributes::MaybeDestroy(Type aNewType) -> bool
3704 : {
3705 868 : if ((mType) == (T__None)) {
3706 372 : return true;
3707 : }
3708 496 : if ((mType) == (aNewType)) {
3709 0 : return false;
3710 : }
3711 496 : switch (mType) {
3712 : case Tnull_t:
3713 : {
3714 124 : (ptr_null_t())->~null_t__tdef();
3715 124 : break;
3716 : }
3717 : case TPaintedLayerAttributes:
3718 : {
3719 159 : (ptr_PaintedLayerAttributes())->~PaintedLayerAttributes__tdef();
3720 159 : break;
3721 : }
3722 : case TContainerLayerAttributes:
3723 : {
3724 129 : (ptr_ContainerLayerAttributes())->~ContainerLayerAttributes__tdef();
3725 129 : break;
3726 : }
3727 : case TColorLayerAttributes:
3728 : {
3729 12 : (ptr_ColorLayerAttributes())->~ColorLayerAttributes__tdef();
3730 12 : break;
3731 : }
3732 : case TCanvasLayerAttributes:
3733 : {
3734 0 : (ptr_CanvasLayerAttributes())->~CanvasLayerAttributes__tdef();
3735 0 : break;
3736 : }
3737 : case TTextLayerAttributes:
3738 : {
3739 0 : (ptr_TextLayerAttributes())->~TextLayerAttributes__tdef();
3740 0 : break;
3741 : }
3742 : case TRefLayerAttributes:
3743 : {
3744 72 : (ptr_RefLayerAttributes())->~RefLayerAttributes__tdef();
3745 72 : break;
3746 : }
3747 : case TImageLayerAttributes:
3748 : {
3749 0 : (ptr_ImageLayerAttributes())->~ImageLayerAttributes__tdef();
3750 0 : break;
3751 : }
3752 : case TBorderLayerAttributes:
3753 : {
3754 0 : (ptr_BorderLayerAttributes())->~BorderLayerAttributes__tdef();
3755 0 : break;
3756 : }
3757 : default:
3758 : {
3759 0 : mozilla::ipc::LogicError("not reached");
3760 0 : break;
3761 : }
3762 : }
3763 496 : return true;
3764 : }
3765 :
3766 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const null_t& aOther)
3767 : {
3768 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
3769 0 : mType = Tnull_t;
3770 0 : }
3771 :
3772 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const PaintedLayerAttributes& aOther)
3773 : {
3774 0 : new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes(aOther);
3775 0 : mType = TPaintedLayerAttributes;
3776 0 : }
3777 :
3778 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ContainerLayerAttributes& aOther)
3779 : {
3780 0 : new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes(aOther);
3781 0 : mType = TContainerLayerAttributes;
3782 0 : }
3783 :
3784 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ColorLayerAttributes& aOther)
3785 : {
3786 0 : new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes(aOther);
3787 0 : mType = TColorLayerAttributes;
3788 0 : }
3789 :
3790 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const CanvasLayerAttributes& aOther)
3791 : {
3792 0 : new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes(aOther);
3793 0 : mType = TCanvasLayerAttributes;
3794 0 : }
3795 :
3796 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const TextLayerAttributes& aOther)
3797 : {
3798 0 : new (mozilla::KnownNotNull, ptr_TextLayerAttributes()) TextLayerAttributes(aOther);
3799 0 : mType = TTextLayerAttributes;
3800 0 : }
3801 :
3802 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const RefLayerAttributes& aOther)
3803 : {
3804 0 : new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes(aOther);
3805 0 : mType = TRefLayerAttributes;
3806 0 : }
3807 :
3808 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const ImageLayerAttributes& aOther)
3809 : {
3810 0 : new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes(aOther);
3811 0 : mType = TImageLayerAttributes;
3812 0 : }
3813 :
3814 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const BorderLayerAttributes& aOther)
3815 : {
3816 0 : new (mozilla::KnownNotNull, ptr_BorderLayerAttributes()) BorderLayerAttributes(aOther);
3817 0 : mType = TBorderLayerAttributes;
3818 0 : }
3819 :
3820 0 : MOZ_IMPLICIT SpecificLayerAttributes::SpecificLayerAttributes(const SpecificLayerAttributes& aOther)
3821 : {
3822 0 : (aOther).AssertSanity();
3823 0 : switch ((aOther).type()) {
3824 : case Tnull_t:
3825 : {
3826 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
3827 0 : break;
3828 : }
3829 : case TPaintedLayerAttributes:
3830 : {
3831 0 : new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes((aOther).get_PaintedLayerAttributes());
3832 0 : break;
3833 : }
3834 : case TContainerLayerAttributes:
3835 : {
3836 0 : new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes((aOther).get_ContainerLayerAttributes());
3837 0 : break;
3838 : }
3839 : case TColorLayerAttributes:
3840 : {
3841 0 : new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes((aOther).get_ColorLayerAttributes());
3842 0 : break;
3843 : }
3844 : case TCanvasLayerAttributes:
3845 : {
3846 0 : new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes((aOther).get_CanvasLayerAttributes());
3847 0 : break;
3848 : }
3849 : case TTextLayerAttributes:
3850 : {
3851 0 : new (mozilla::KnownNotNull, ptr_TextLayerAttributes()) TextLayerAttributes((aOther).get_TextLayerAttributes());
3852 0 : break;
3853 : }
3854 : case TRefLayerAttributes:
3855 : {
3856 0 : new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes((aOther).get_RefLayerAttributes());
3857 0 : break;
3858 : }
3859 : case TImageLayerAttributes:
3860 : {
3861 0 : new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes((aOther).get_ImageLayerAttributes());
3862 0 : break;
3863 : }
3864 : case TBorderLayerAttributes:
3865 : {
3866 0 : new (mozilla::KnownNotNull, ptr_BorderLayerAttributes()) BorderLayerAttributes((aOther).get_BorderLayerAttributes());
3867 0 : break;
3868 : }
3869 : case T__None:
3870 : {
3871 0 : break;
3872 : }
3873 : default:
3874 : {
3875 0 : mozilla::ipc::LogicError("unreached");
3876 0 : return;
3877 : }
3878 : }
3879 0 : mType = (aOther).type();
3880 : }
3881 :
3882 744 : SpecificLayerAttributes::~SpecificLayerAttributes()
3883 : {
3884 372 : static_cast<void>(MaybeDestroy(T__None));
3885 372 : }
3886 :
3887 124 : auto SpecificLayerAttributes::operator=(const null_t& aRhs) -> SpecificLayerAttributes&
3888 : {
3889 124 : if (MaybeDestroy(Tnull_t)) {
3890 124 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
3891 : }
3892 124 : (*(ptr_null_t())) = aRhs;
3893 124 : mType = Tnull_t;
3894 124 : return (*(this));
3895 : }
3896 :
3897 106 : auto SpecificLayerAttributes::operator=(const PaintedLayerAttributes& aRhs) -> SpecificLayerAttributes&
3898 : {
3899 106 : if (MaybeDestroy(TPaintedLayerAttributes)) {
3900 106 : new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
3901 : }
3902 106 : (*(ptr_PaintedLayerAttributes())) = aRhs;
3903 106 : mType = TPaintedLayerAttributes;
3904 106 : return (*(this));
3905 : }
3906 :
3907 86 : auto SpecificLayerAttributes::operator=(const ContainerLayerAttributes& aRhs) -> SpecificLayerAttributes&
3908 : {
3909 86 : if (MaybeDestroy(TContainerLayerAttributes)) {
3910 86 : new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
3911 : }
3912 86 : (*(ptr_ContainerLayerAttributes())) = aRhs;
3913 86 : mType = TContainerLayerAttributes;
3914 86 : return (*(this));
3915 : }
3916 :
3917 8 : auto SpecificLayerAttributes::operator=(const ColorLayerAttributes& aRhs) -> SpecificLayerAttributes&
3918 : {
3919 8 : if (MaybeDestroy(TColorLayerAttributes)) {
3920 8 : new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
3921 : }
3922 8 : (*(ptr_ColorLayerAttributes())) = aRhs;
3923 8 : mType = TColorLayerAttributes;
3924 8 : return (*(this));
3925 : }
3926 :
3927 0 : auto SpecificLayerAttributes::operator=(const CanvasLayerAttributes& aRhs) -> SpecificLayerAttributes&
3928 : {
3929 0 : if (MaybeDestroy(TCanvasLayerAttributes)) {
3930 0 : new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
3931 : }
3932 0 : (*(ptr_CanvasLayerAttributes())) = aRhs;
3933 0 : mType = TCanvasLayerAttributes;
3934 0 : return (*(this));
3935 : }
3936 :
3937 0 : auto SpecificLayerAttributes::operator=(const TextLayerAttributes& aRhs) -> SpecificLayerAttributes&
3938 : {
3939 0 : if (MaybeDestroy(TTextLayerAttributes)) {
3940 0 : new (mozilla::KnownNotNull, ptr_TextLayerAttributes()) TextLayerAttributes;
3941 : }
3942 0 : (*(ptr_TextLayerAttributes())) = aRhs;
3943 0 : mType = TTextLayerAttributes;
3944 0 : return (*(this));
3945 : }
3946 :
3947 48 : auto SpecificLayerAttributes::operator=(const RefLayerAttributes& aRhs) -> SpecificLayerAttributes&
3948 : {
3949 48 : if (MaybeDestroy(TRefLayerAttributes)) {
3950 48 : new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
3951 : }
3952 48 : (*(ptr_RefLayerAttributes())) = aRhs;
3953 48 : mType = TRefLayerAttributes;
3954 48 : return (*(this));
3955 : }
3956 :
3957 0 : auto SpecificLayerAttributes::operator=(const ImageLayerAttributes& aRhs) -> SpecificLayerAttributes&
3958 : {
3959 0 : if (MaybeDestroy(TImageLayerAttributes)) {
3960 0 : new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
3961 : }
3962 0 : (*(ptr_ImageLayerAttributes())) = aRhs;
3963 0 : mType = TImageLayerAttributes;
3964 0 : return (*(this));
3965 : }
3966 :
3967 0 : auto SpecificLayerAttributes::operator=(const BorderLayerAttributes& aRhs) -> SpecificLayerAttributes&
3968 : {
3969 0 : if (MaybeDestroy(TBorderLayerAttributes)) {
3970 0 : new (mozilla::KnownNotNull, ptr_BorderLayerAttributes()) BorderLayerAttributes;
3971 : }
3972 0 : (*(ptr_BorderLayerAttributes())) = aRhs;
3973 0 : mType = TBorderLayerAttributes;
3974 0 : return (*(this));
3975 : }
3976 :
3977 124 : auto SpecificLayerAttributes::operator=(const SpecificLayerAttributes& aRhs) -> SpecificLayerAttributes&
3978 : {
3979 124 : (aRhs).AssertSanity();
3980 124 : Type t = (aRhs).type();
3981 124 : switch (t) {
3982 : case Tnull_t:
3983 : {
3984 0 : if (MaybeDestroy(t)) {
3985 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
3986 : }
3987 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
3988 0 : break;
3989 : }
3990 : case TPaintedLayerAttributes:
3991 : {
3992 53 : if (MaybeDestroy(t)) {
3993 53 : new (mozilla::KnownNotNull, ptr_PaintedLayerAttributes()) PaintedLayerAttributes;
3994 : }
3995 53 : (*(ptr_PaintedLayerAttributes())) = (aRhs).get_PaintedLayerAttributes();
3996 53 : break;
3997 : }
3998 : case TContainerLayerAttributes:
3999 : {
4000 43 : if (MaybeDestroy(t)) {
4001 43 : new (mozilla::KnownNotNull, ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
4002 : }
4003 43 : (*(ptr_ContainerLayerAttributes())) = (aRhs).get_ContainerLayerAttributes();
4004 43 : break;
4005 : }
4006 : case TColorLayerAttributes:
4007 : {
4008 4 : if (MaybeDestroy(t)) {
4009 4 : new (mozilla::KnownNotNull, ptr_ColorLayerAttributes()) ColorLayerAttributes;
4010 : }
4011 4 : (*(ptr_ColorLayerAttributes())) = (aRhs).get_ColorLayerAttributes();
4012 4 : break;
4013 : }
4014 : case TCanvasLayerAttributes:
4015 : {
4016 0 : if (MaybeDestroy(t)) {
4017 0 : new (mozilla::KnownNotNull, ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
4018 : }
4019 0 : (*(ptr_CanvasLayerAttributes())) = (aRhs).get_CanvasLayerAttributes();
4020 0 : break;
4021 : }
4022 : case TTextLayerAttributes:
4023 : {
4024 0 : if (MaybeDestroy(t)) {
4025 0 : new (mozilla::KnownNotNull, ptr_TextLayerAttributes()) TextLayerAttributes;
4026 : }
4027 0 : (*(ptr_TextLayerAttributes())) = (aRhs).get_TextLayerAttributes();
4028 0 : break;
4029 : }
4030 : case TRefLayerAttributes:
4031 : {
4032 24 : if (MaybeDestroy(t)) {
4033 24 : new (mozilla::KnownNotNull, ptr_RefLayerAttributes()) RefLayerAttributes;
4034 : }
4035 24 : (*(ptr_RefLayerAttributes())) = (aRhs).get_RefLayerAttributes();
4036 24 : break;
4037 : }
4038 : case TImageLayerAttributes:
4039 : {
4040 0 : if (MaybeDestroy(t)) {
4041 0 : new (mozilla::KnownNotNull, ptr_ImageLayerAttributes()) ImageLayerAttributes;
4042 : }
4043 0 : (*(ptr_ImageLayerAttributes())) = (aRhs).get_ImageLayerAttributes();
4044 0 : break;
4045 : }
4046 : case TBorderLayerAttributes:
4047 : {
4048 0 : if (MaybeDestroy(t)) {
4049 0 : new (mozilla::KnownNotNull, ptr_BorderLayerAttributes()) BorderLayerAttributes;
4050 : }
4051 0 : (*(ptr_BorderLayerAttributes())) = (aRhs).get_BorderLayerAttributes();
4052 0 : break;
4053 : }
4054 : case T__None:
4055 : {
4056 0 : static_cast<void>(MaybeDestroy(t));
4057 0 : break;
4058 : }
4059 : default:
4060 : {
4061 0 : mozilla::ipc::LogicError("unreached");
4062 0 : break;
4063 : }
4064 : }
4065 124 : mType = t;
4066 124 : return (*(this));
4067 : }
4068 :
4069 0 : auto SpecificLayerAttributes::operator==(const null_t& aRhs) const -> bool
4070 : {
4071 0 : return (get_null_t()) == (aRhs);
4072 : }
4073 :
4074 0 : auto SpecificLayerAttributes::operator==(const PaintedLayerAttributes& aRhs) const -> bool
4075 : {
4076 0 : return (get_PaintedLayerAttributes()) == (aRhs);
4077 : }
4078 :
4079 0 : auto SpecificLayerAttributes::operator==(const ContainerLayerAttributes& aRhs) const -> bool
4080 : {
4081 0 : return (get_ContainerLayerAttributes()) == (aRhs);
4082 : }
4083 :
4084 0 : auto SpecificLayerAttributes::operator==(const ColorLayerAttributes& aRhs) const -> bool
4085 : {
4086 0 : return (get_ColorLayerAttributes()) == (aRhs);
4087 : }
4088 :
4089 0 : auto SpecificLayerAttributes::operator==(const CanvasLayerAttributes& aRhs) const -> bool
4090 : {
4091 0 : return (get_CanvasLayerAttributes()) == (aRhs);
4092 : }
4093 :
4094 0 : auto SpecificLayerAttributes::operator==(const TextLayerAttributes& aRhs) const -> bool
4095 : {
4096 0 : return (get_TextLayerAttributes()) == (aRhs);
4097 : }
4098 :
4099 0 : auto SpecificLayerAttributes::operator==(const RefLayerAttributes& aRhs) const -> bool
4100 : {
4101 0 : return (get_RefLayerAttributes()) == (aRhs);
4102 : }
4103 :
4104 0 : auto SpecificLayerAttributes::operator==(const ImageLayerAttributes& aRhs) const -> bool
4105 : {
4106 0 : return (get_ImageLayerAttributes()) == (aRhs);
4107 : }
4108 :
4109 0 : auto SpecificLayerAttributes::operator==(const BorderLayerAttributes& aRhs) const -> bool
4110 : {
4111 0 : return (get_BorderLayerAttributes()) == (aRhs);
4112 : }
4113 :
4114 0 : auto SpecificLayerAttributes::operator==(const SpecificLayerAttributes& aRhs) const -> bool
4115 : {
4116 0 : if ((type()) != ((aRhs).type())) {
4117 0 : return false;
4118 : }
4119 :
4120 0 : switch (type()) {
4121 : case Tnull_t:
4122 : {
4123 0 : return (get_null_t()) == ((aRhs).get_null_t());
4124 : }
4125 : case TPaintedLayerAttributes:
4126 : {
4127 0 : return (get_PaintedLayerAttributes()) == ((aRhs).get_PaintedLayerAttributes());
4128 : }
4129 : case TContainerLayerAttributes:
4130 : {
4131 0 : return (get_ContainerLayerAttributes()) == ((aRhs).get_ContainerLayerAttributes());
4132 : }
4133 : case TColorLayerAttributes:
4134 : {
4135 0 : return (get_ColorLayerAttributes()) == ((aRhs).get_ColorLayerAttributes());
4136 : }
4137 : case TCanvasLayerAttributes:
4138 : {
4139 0 : return (get_CanvasLayerAttributes()) == ((aRhs).get_CanvasLayerAttributes());
4140 : }
4141 : case TTextLayerAttributes:
4142 : {
4143 0 : return (get_TextLayerAttributes()) == ((aRhs).get_TextLayerAttributes());
4144 : }
4145 : case TRefLayerAttributes:
4146 : {
4147 0 : return (get_RefLayerAttributes()) == ((aRhs).get_RefLayerAttributes());
4148 : }
4149 : case TImageLayerAttributes:
4150 : {
4151 0 : return (get_ImageLayerAttributes()) == ((aRhs).get_ImageLayerAttributes());
4152 : }
4153 : case TBorderLayerAttributes:
4154 : {
4155 0 : return (get_BorderLayerAttributes()) == ((aRhs).get_BorderLayerAttributes());
4156 : }
4157 : default:
4158 : {
4159 0 : mozilla::ipc::LogicError("unreached");
4160 0 : return false;
4161 : }
4162 : }
4163 : }
4164 :
4165 0 : auto SpecificLayerAttributes::get(null_t* aOutValue) const -> void
4166 : {
4167 0 : (*(aOutValue)) = get_null_t();
4168 0 : }
4169 :
4170 0 : auto SpecificLayerAttributes::get(PaintedLayerAttributes* aOutValue) const -> void
4171 : {
4172 0 : (*(aOutValue)) = get_PaintedLayerAttributes();
4173 0 : }
4174 :
4175 0 : auto SpecificLayerAttributes::get(ContainerLayerAttributes* aOutValue) const -> void
4176 : {
4177 0 : (*(aOutValue)) = get_ContainerLayerAttributes();
4178 0 : }
4179 :
4180 0 : auto SpecificLayerAttributes::get(ColorLayerAttributes* aOutValue) const -> void
4181 : {
4182 0 : (*(aOutValue)) = get_ColorLayerAttributes();
4183 0 : }
4184 :
4185 0 : auto SpecificLayerAttributes::get(CanvasLayerAttributes* aOutValue) const -> void
4186 : {
4187 0 : (*(aOutValue)) = get_CanvasLayerAttributes();
4188 0 : }
4189 :
4190 0 : auto SpecificLayerAttributes::get(TextLayerAttributes* aOutValue) const -> void
4191 : {
4192 0 : (*(aOutValue)) = get_TextLayerAttributes();
4193 0 : }
4194 :
4195 0 : auto SpecificLayerAttributes::get(RefLayerAttributes* aOutValue) const -> void
4196 : {
4197 0 : (*(aOutValue)) = get_RefLayerAttributes();
4198 0 : }
4199 :
4200 0 : auto SpecificLayerAttributes::get(ImageLayerAttributes* aOutValue) const -> void
4201 : {
4202 0 : (*(aOutValue)) = get_ImageLayerAttributes();
4203 0 : }
4204 :
4205 0 : auto SpecificLayerAttributes::get(BorderLayerAttributes* aOutValue) const -> void
4206 : {
4207 0 : (*(aOutValue)) = get_BorderLayerAttributes();
4208 0 : }
4209 :
4210 : } // namespace layers
4211 : } // namespace mozilla
4212 :
4213 : //-----------------------------------------------------------------------------
4214 : // Method definitions for the IPDL type |struct LayerAttributes|
4215 : //
4216 : namespace mozilla {
4217 : namespace layers {
4218 372 : MOZ_IMPLICIT LayerAttributes::LayerAttributes()
4219 : {
4220 372 : Init();
4221 372 : }
4222 :
4223 372 : LayerAttributes::~LayerAttributes()
4224 : {
4225 372 : }
4226 :
4227 0 : auto LayerAttributes::operator==(const LayerAttributes& _o) const -> bool
4228 : {
4229 0 : if ((!((common()) == ((_o).common())))) {
4230 0 : return false;
4231 : }
4232 0 : if ((!((specific()) == ((_o).specific())))) {
4233 0 : return false;
4234 : }
4235 0 : return true;
4236 : }
4237 :
4238 0 : auto LayerAttributes::operator!=(const LayerAttributes& _o) const -> bool
4239 : {
4240 0 : return (!(operator==(_o)));
4241 : }
4242 :
4243 372 : auto LayerAttributes::Init() -> void
4244 : {
4245 372 : }
4246 :
4247 124 : auto LayerAttributes::Assign(
4248 : const CommonLayerAttributes& _common,
4249 : const SpecificLayerAttributes& _specific) -> void
4250 : {
4251 124 : common_ = _common;
4252 124 : specific_ = _specific;
4253 124 : }
4254 :
4255 : } // namespace layers
4256 : } // namespace mozilla
4257 :
4258 : //-----------------------------------------------------------------------------
4259 : // Method definitions for the IPDL type |struct PluginWindowData|
4260 : //
4261 : namespace mozilla {
4262 : namespace layers {
4263 0 : MOZ_IMPLICIT PluginWindowData::PluginWindowData() :
4264 : windowId_(),
4265 : bounds_(),
4266 0 : visible_()
4267 : {
4268 0 : Init();
4269 0 : }
4270 :
4271 0 : PluginWindowData::~PluginWindowData()
4272 : {
4273 0 : }
4274 :
4275 0 : auto PluginWindowData::operator==(const PluginWindowData& _o) const -> bool
4276 : {
4277 0 : if ((!((windowId()) == ((_o).windowId())))) {
4278 0 : return false;
4279 : }
4280 0 : if ((!((clip()) == ((_o).clip())))) {
4281 0 : return false;
4282 : }
4283 0 : if ((!((bounds()) == ((_o).bounds())))) {
4284 0 : return false;
4285 : }
4286 0 : if ((!((visible()) == ((_o).visible())))) {
4287 0 : return false;
4288 : }
4289 0 : return true;
4290 : }
4291 :
4292 0 : auto PluginWindowData::operator!=(const PluginWindowData& _o) const -> bool
4293 : {
4294 0 : return (!(operator==(_o)));
4295 : }
4296 :
4297 0 : auto PluginWindowData::Init() -> void
4298 : {
4299 0 : }
4300 :
4301 0 : auto PluginWindowData::Assign(
4302 : const uintptr_t& _windowId,
4303 : const nsTArray<LayoutDeviceIntRect>& _clip,
4304 : const LayoutDeviceIntRect& _bounds,
4305 : const bool& _visible) -> void
4306 : {
4307 0 : windowId_ = _windowId;
4308 0 : clip_ = _clip;
4309 0 : bounds_ = _bounds;
4310 0 : visible_ = _visible;
4311 0 : }
4312 :
4313 : } // namespace layers
4314 : } // namespace mozilla
4315 :
4316 : //-----------------------------------------------------------------------------
4317 : // Method definitions for the IPDL type |struct OpSetSimpleLayerAttributes|
4318 : //
4319 : namespace mozilla {
4320 : namespace layers {
4321 24 : MOZ_IMPLICIT OpSetSimpleLayerAttributes::OpSetSimpleLayerAttributes() :
4322 : layer_(),
4323 24 : attrs_()
4324 : {
4325 24 : Init();
4326 24 : }
4327 :
4328 72 : OpSetSimpleLayerAttributes::~OpSetSimpleLayerAttributes()
4329 : {
4330 72 : }
4331 :
4332 0 : auto OpSetSimpleLayerAttributes::operator==(const OpSetSimpleLayerAttributes& _o) const -> bool
4333 : {
4334 0 : if ((!((layer()) == ((_o).layer())))) {
4335 0 : return false;
4336 : }
4337 0 : if ((!((attrs()) == ((_o).attrs())))) {
4338 0 : return false;
4339 : }
4340 0 : return true;
4341 : }
4342 :
4343 0 : auto OpSetSimpleLayerAttributes::operator!=(const OpSetSimpleLayerAttributes& _o) const -> bool
4344 : {
4345 0 : return (!(operator==(_o)));
4346 : }
4347 :
4348 72 : auto OpSetSimpleLayerAttributes::Init() -> void
4349 : {
4350 72 : }
4351 :
4352 48 : auto OpSetSimpleLayerAttributes::Assign(
4353 : const LayerHandle& _layer,
4354 : const SimpleLayerAttributes& _attrs) -> void
4355 : {
4356 48 : layer_ = _layer;
4357 48 : attrs_ = _attrs;
4358 48 : }
4359 :
4360 : } // namespace layers
4361 : } // namespace mozilla
4362 :
4363 : //-----------------------------------------------------------------------------
4364 : // Method definitions for the IPDL type |struct OpSetLayerAttributes|
4365 : //
4366 : namespace mozilla {
4367 : namespace layers {
4368 248 : MOZ_IMPLICIT OpSetLayerAttributes::OpSetLayerAttributes() :
4369 248 : layer_()
4370 : {
4371 248 : Init();
4372 248 : }
4373 :
4374 372 : OpSetLayerAttributes::~OpSetLayerAttributes()
4375 : {
4376 372 : }
4377 :
4378 0 : auto OpSetLayerAttributes::operator==(const OpSetLayerAttributes& _o) const -> bool
4379 : {
4380 0 : if ((!((layer()) == ((_o).layer())))) {
4381 0 : return false;
4382 : }
4383 0 : if ((!((attrs()) == ((_o).attrs())))) {
4384 0 : return false;
4385 : }
4386 0 : return true;
4387 : }
4388 :
4389 0 : auto OpSetLayerAttributes::operator!=(const OpSetLayerAttributes& _o) const -> bool
4390 : {
4391 0 : return (!(operator==(_o)));
4392 : }
4393 :
4394 372 : auto OpSetLayerAttributes::Init() -> void
4395 : {
4396 372 : }
4397 :
4398 124 : auto OpSetLayerAttributes::Assign(
4399 : const LayerHandle& _layer,
4400 : const LayerAttributes& _attrs) -> void
4401 : {
4402 124 : layer_ = _layer;
4403 124 : attrs_ = _attrs;
4404 124 : }
4405 :
4406 : } // namespace layers
4407 : } // namespace mozilla
4408 :
4409 : //-----------------------------------------------------------------------------
4410 : // Method definitions for the IPDL type |struct OpSetRoot|
4411 : //
4412 : namespace mozilla {
4413 : namespace layers {
4414 8 : MOZ_IMPLICIT OpSetRoot::OpSetRoot() :
4415 8 : root_()
4416 : {
4417 8 : Init();
4418 8 : }
4419 :
4420 20 : OpSetRoot::~OpSetRoot()
4421 : {
4422 20 : }
4423 :
4424 0 : auto OpSetRoot::operator==(const OpSetRoot& _o) const -> bool
4425 : {
4426 0 : if ((!((root()) == ((_o).root())))) {
4427 0 : return false;
4428 : }
4429 0 : return true;
4430 : }
4431 :
4432 0 : auto OpSetRoot::operator!=(const OpSetRoot& _o) const -> bool
4433 : {
4434 0 : return (!(operator==(_o)));
4435 : }
4436 :
4437 20 : auto OpSetRoot::Init() -> void
4438 : {
4439 20 : }
4440 :
4441 16 : auto OpSetRoot::Assign(const LayerHandle& _root) -> void
4442 : {
4443 16 : root_ = _root;
4444 16 : }
4445 :
4446 : } // namespace layers
4447 : } // namespace mozilla
4448 :
4449 : //-----------------------------------------------------------------------------
4450 : // Method definitions for the IPDL type |struct OpInsertAfter|
4451 : //
4452 : namespace mozilla {
4453 : namespace layers {
4454 46 : MOZ_IMPLICIT OpInsertAfter::OpInsertAfter() :
4455 : container_(),
4456 : childLayer_(),
4457 46 : after_()
4458 : {
4459 46 : Init();
4460 46 : }
4461 :
4462 115 : OpInsertAfter::~OpInsertAfter()
4463 : {
4464 115 : }
4465 :
4466 0 : auto OpInsertAfter::operator==(const OpInsertAfter& _o) const -> bool
4467 : {
4468 0 : if ((!((container()) == ((_o).container())))) {
4469 0 : return false;
4470 : }
4471 0 : if ((!((childLayer()) == ((_o).childLayer())))) {
4472 0 : return false;
4473 : }
4474 0 : if ((!((after()) == ((_o).after())))) {
4475 0 : return false;
4476 : }
4477 0 : return true;
4478 : }
4479 :
4480 0 : auto OpInsertAfter::operator!=(const OpInsertAfter& _o) const -> bool
4481 : {
4482 0 : return (!(operator==(_o)));
4483 : }
4484 :
4485 115 : auto OpInsertAfter::Init() -> void
4486 : {
4487 115 : }
4488 :
4489 92 : auto OpInsertAfter::Assign(
4490 : const LayerHandle& _container,
4491 : const LayerHandle& _childLayer,
4492 : const LayerHandle& _after) -> void
4493 : {
4494 92 : container_ = _container;
4495 92 : childLayer_ = _childLayer;
4496 92 : after_ = _after;
4497 92 : }
4498 :
4499 : } // namespace layers
4500 : } // namespace mozilla
4501 :
4502 : //-----------------------------------------------------------------------------
4503 : // Method definitions for the IPDL type |struct OpPrependChild|
4504 : //
4505 : namespace mozilla {
4506 : namespace layers {
4507 8 : MOZ_IMPLICIT OpPrependChild::OpPrependChild() :
4508 : container_(),
4509 8 : childLayer_()
4510 : {
4511 8 : Init();
4512 8 : }
4513 :
4514 20 : OpPrependChild::~OpPrependChild()
4515 : {
4516 20 : }
4517 :
4518 0 : auto OpPrependChild::operator==(const OpPrependChild& _o) const -> bool
4519 : {
4520 0 : if ((!((container()) == ((_o).container())))) {
4521 0 : return false;
4522 : }
4523 0 : if ((!((childLayer()) == ((_o).childLayer())))) {
4524 0 : return false;
4525 : }
4526 0 : return true;
4527 : }
4528 :
4529 0 : auto OpPrependChild::operator!=(const OpPrependChild& _o) const -> bool
4530 : {
4531 0 : return (!(operator==(_o)));
4532 : }
4533 :
4534 20 : auto OpPrependChild::Init() -> void
4535 : {
4536 20 : }
4537 :
4538 16 : auto OpPrependChild::Assign(
4539 : const LayerHandle& _container,
4540 : const LayerHandle& _childLayer) -> void
4541 : {
4542 16 : container_ = _container;
4543 16 : childLayer_ = _childLayer;
4544 16 : }
4545 :
4546 : } // namespace layers
4547 : } // namespace mozilla
4548 :
4549 : //-----------------------------------------------------------------------------
4550 : // Method definitions for the IPDL type |struct OpRemoveChild|
4551 : //
4552 : namespace mozilla {
4553 : namespace layers {
4554 40 : MOZ_IMPLICIT OpRemoveChild::OpRemoveChild() :
4555 : container_(),
4556 40 : childLayer_()
4557 : {
4558 40 : Init();
4559 40 : }
4560 :
4561 100 : OpRemoveChild::~OpRemoveChild()
4562 : {
4563 100 : }
4564 :
4565 0 : auto OpRemoveChild::operator==(const OpRemoveChild& _o) const -> bool
4566 : {
4567 0 : if ((!((container()) == ((_o).container())))) {
4568 0 : return false;
4569 : }
4570 0 : if ((!((childLayer()) == ((_o).childLayer())))) {
4571 0 : return false;
4572 : }
4573 0 : return true;
4574 : }
4575 :
4576 0 : auto OpRemoveChild::operator!=(const OpRemoveChild& _o) const -> bool
4577 : {
4578 0 : return (!(operator==(_o)));
4579 : }
4580 :
4581 100 : auto OpRemoveChild::Init() -> void
4582 : {
4583 100 : }
4584 :
4585 80 : auto OpRemoveChild::Assign(
4586 : const LayerHandle& _container,
4587 : const LayerHandle& _childLayer) -> void
4588 : {
4589 80 : container_ = _container;
4590 80 : childLayer_ = _childLayer;
4591 80 : }
4592 :
4593 : } // namespace layers
4594 : } // namespace mozilla
4595 :
4596 : //-----------------------------------------------------------------------------
4597 : // Method definitions for the IPDL type |struct OpRepositionChild|
4598 : //
4599 : namespace mozilla {
4600 : namespace layers {
4601 0 : MOZ_IMPLICIT OpRepositionChild::OpRepositionChild() :
4602 : container_(),
4603 : childLayer_(),
4604 0 : after_()
4605 : {
4606 0 : Init();
4607 0 : }
4608 :
4609 0 : OpRepositionChild::~OpRepositionChild()
4610 : {
4611 0 : }
4612 :
4613 0 : auto OpRepositionChild::operator==(const OpRepositionChild& _o) const -> bool
4614 : {
4615 0 : if ((!((container()) == ((_o).container())))) {
4616 0 : return false;
4617 : }
4618 0 : if ((!((childLayer()) == ((_o).childLayer())))) {
4619 0 : return false;
4620 : }
4621 0 : if ((!((after()) == ((_o).after())))) {
4622 0 : return false;
4623 : }
4624 0 : return true;
4625 : }
4626 :
4627 0 : auto OpRepositionChild::operator!=(const OpRepositionChild& _o) const -> bool
4628 : {
4629 0 : return (!(operator==(_o)));
4630 : }
4631 :
4632 0 : auto OpRepositionChild::Init() -> void
4633 : {
4634 0 : }
4635 :
4636 0 : auto OpRepositionChild::Assign(
4637 : const LayerHandle& _container,
4638 : const LayerHandle& _childLayer,
4639 : const LayerHandle& _after) -> void
4640 : {
4641 0 : container_ = _container;
4642 0 : childLayer_ = _childLayer;
4643 0 : after_ = _after;
4644 0 : }
4645 :
4646 : } // namespace layers
4647 : } // namespace mozilla
4648 :
4649 : //-----------------------------------------------------------------------------
4650 : // Method definitions for the IPDL type |struct OpRaiseToTopChild|
4651 : //
4652 : namespace mozilla {
4653 : namespace layers {
4654 0 : MOZ_IMPLICIT OpRaiseToTopChild::OpRaiseToTopChild() :
4655 : container_(),
4656 0 : childLayer_()
4657 : {
4658 0 : Init();
4659 0 : }
4660 :
4661 0 : OpRaiseToTopChild::~OpRaiseToTopChild()
4662 : {
4663 0 : }
4664 :
4665 0 : auto OpRaiseToTopChild::operator==(const OpRaiseToTopChild& _o) const -> bool
4666 : {
4667 0 : if ((!((container()) == ((_o).container())))) {
4668 0 : return false;
4669 : }
4670 0 : if ((!((childLayer()) == ((_o).childLayer())))) {
4671 0 : return false;
4672 : }
4673 0 : return true;
4674 : }
4675 :
4676 0 : auto OpRaiseToTopChild::operator!=(const OpRaiseToTopChild& _o) const -> bool
4677 : {
4678 0 : return (!(operator==(_o)));
4679 : }
4680 :
4681 0 : auto OpRaiseToTopChild::Init() -> void
4682 : {
4683 0 : }
4684 :
4685 0 : auto OpRaiseToTopChild::Assign(
4686 : const LayerHandle& _container,
4687 : const LayerHandle& _childLayer) -> void
4688 : {
4689 0 : container_ = _container;
4690 0 : childLayer_ = _childLayer;
4691 0 : }
4692 :
4693 : } // namespace layers
4694 : } // namespace mozilla
4695 :
4696 : //-----------------------------------------------------------------------------
4697 : // Method definitions for the IPDL type |struct OpSetDiagnosticTypes|
4698 : //
4699 : namespace mozilla {
4700 : namespace layers {
4701 0 : MOZ_IMPLICIT OpSetDiagnosticTypes::OpSetDiagnosticTypes() :
4702 0 : diagnostics_()
4703 : {
4704 0 : Init();
4705 0 : }
4706 :
4707 0 : OpSetDiagnosticTypes::~OpSetDiagnosticTypes()
4708 : {
4709 0 : }
4710 :
4711 0 : auto OpSetDiagnosticTypes::operator==(const OpSetDiagnosticTypes& _o) const -> bool
4712 : {
4713 0 : if ((!((diagnostics()) == ((_o).diagnostics())))) {
4714 0 : return false;
4715 : }
4716 0 : return true;
4717 : }
4718 :
4719 0 : auto OpSetDiagnosticTypes::operator!=(const OpSetDiagnosticTypes& _o) const -> bool
4720 : {
4721 0 : return (!(operator==(_o)));
4722 : }
4723 :
4724 0 : auto OpSetDiagnosticTypes::Init() -> void
4725 : {
4726 0 : }
4727 :
4728 0 : auto OpSetDiagnosticTypes::Assign(const DiagnosticTypes& _diagnostics) -> void
4729 : {
4730 0 : diagnostics_ = _diagnostics;
4731 0 : }
4732 :
4733 : } // namespace layers
4734 : } // namespace mozilla
4735 :
4736 : //-----------------------------------------------------------------------------
4737 : // Method definitions for the IPDL type |struct OpWindowOverlayChanged|
4738 : //
4739 : namespace mozilla {
4740 : namespace layers {
4741 0 : OpWindowOverlayChanged::~OpWindowOverlayChanged()
4742 : {
4743 0 : }
4744 :
4745 0 : auto OpWindowOverlayChanged::operator==(const OpWindowOverlayChanged& _o) const -> bool
4746 : {
4747 0 : return true;
4748 : }
4749 :
4750 0 : auto OpWindowOverlayChanged::operator!=(const OpWindowOverlayChanged& _o) const -> bool
4751 : {
4752 0 : return (!(operator==(_o)));
4753 : }
4754 :
4755 0 : auto OpWindowOverlayChanged::Init() -> void
4756 : {
4757 0 : }
4758 :
4759 0 : auto OpWindowOverlayChanged::Assign() -> void
4760 : {
4761 0 : }
4762 :
4763 : } // namespace layers
4764 : } // namespace mozilla
4765 :
4766 : //-----------------------------------------------------------------------------
4767 : // Method definitions for the IPDL type |struct ShmemSection|
4768 : //
4769 : namespace mozilla {
4770 : namespace layers {
4771 0 : MOZ_IMPLICIT ShmemSection::ShmemSection() :
4772 : offset_(),
4773 0 : size_()
4774 : {
4775 0 : Init();
4776 0 : }
4777 :
4778 0 : ShmemSection::~ShmemSection()
4779 : {
4780 0 : }
4781 :
4782 0 : auto ShmemSection::operator==(const ShmemSection& _o) const -> bool
4783 : {
4784 0 : if ((!((shmem()) == ((_o).shmem())))) {
4785 0 : return false;
4786 : }
4787 0 : if ((!((offset()) == ((_o).offset())))) {
4788 0 : return false;
4789 : }
4790 0 : if ((!((size()) == ((_o).size())))) {
4791 0 : return false;
4792 : }
4793 0 : return true;
4794 : }
4795 :
4796 0 : auto ShmemSection::operator!=(const ShmemSection& _o) const -> bool
4797 : {
4798 0 : return (!(operator==(_o)));
4799 : }
4800 :
4801 0 : auto ShmemSection::Init() -> void
4802 : {
4803 0 : }
4804 :
4805 0 : auto ShmemSection::Assign(
4806 : Shmem& _shmem,
4807 : const uint32_t& _offset,
4808 : const size_t& _size) -> void
4809 : {
4810 0 : shmem_ = _shmem;
4811 0 : offset_ = _offset;
4812 0 : size_ = _size;
4813 0 : }
4814 :
4815 : } // namespace layers
4816 : } // namespace mozilla
4817 :
4818 : //-----------------------------------------------------------------------------
4819 : // Method definitions for the IPDL type |struct CrossProcessSemaphoreDescriptor|
4820 : //
4821 : namespace mozilla {
4822 : namespace layers {
4823 165 : MOZ_IMPLICIT CrossProcessSemaphoreDescriptor::CrossProcessSemaphoreDescriptor() :
4824 165 : sem_()
4825 : {
4826 165 : Init();
4827 165 : }
4828 :
4829 231 : CrossProcessSemaphoreDescriptor::~CrossProcessSemaphoreDescriptor()
4830 : {
4831 231 : }
4832 :
4833 0 : auto CrossProcessSemaphoreDescriptor::operator==(const CrossProcessSemaphoreDescriptor& _o) const -> bool
4834 : {
4835 0 : if ((!((sem()) == ((_o).sem())))) {
4836 0 : return false;
4837 : }
4838 0 : return true;
4839 : }
4840 :
4841 0 : auto CrossProcessSemaphoreDescriptor::operator!=(const CrossProcessSemaphoreDescriptor& _o) const -> bool
4842 : {
4843 0 : return (!(operator==(_o)));
4844 : }
4845 :
4846 231 : auto CrossProcessSemaphoreDescriptor::Init() -> void
4847 : {
4848 231 : }
4849 :
4850 198 : auto CrossProcessSemaphoreDescriptor::Assign(const CrossProcessSemaphoreHandle& _sem) -> void
4851 : {
4852 198 : sem_ = _sem;
4853 198 : }
4854 :
4855 : } // namespace layers
4856 : } // namespace mozilla
4857 :
4858 : //-----------------------------------------------------------------------------
4859 : // Method definitions for the IPDL type |union ReadLockDescriptor|
4860 : //
4861 : namespace mozilla {
4862 : namespace layers {
4863 297 : auto ReadLockDescriptor::MaybeDestroy(Type aNewType) -> bool
4864 : {
4865 297 : if ((mType) == (T__None)) {
4866 132 : return true;
4867 : }
4868 165 : if ((mType) == (aNewType)) {
4869 0 : return false;
4870 : }
4871 165 : switch (mType) {
4872 : case TShmemSection:
4873 : {
4874 0 : (ptr_ShmemSection())->~ShmemSection__tdef();
4875 0 : break;
4876 : }
4877 : case TCrossProcessSemaphoreDescriptor:
4878 : {
4879 165 : (ptr_CrossProcessSemaphoreDescriptor())->~CrossProcessSemaphoreDescriptor__tdef();
4880 165 : break;
4881 : }
4882 : case Tuintptr_t:
4883 : {
4884 0 : (ptr_uintptr_t())->~uintptr_t__tdef();
4885 0 : break;
4886 : }
4887 : case Tnull_t:
4888 : {
4889 0 : (ptr_null_t())->~null_t__tdef();
4890 0 : break;
4891 : }
4892 : default:
4893 : {
4894 0 : mozilla::ipc::LogicError("not reached");
4895 0 : break;
4896 : }
4897 : }
4898 165 : return true;
4899 : }
4900 :
4901 0 : MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const ShmemSection& aOther)
4902 : {
4903 0 : new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection(aOther);
4904 0 : mType = TShmemSection;
4905 0 : }
4906 :
4907 33 : MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const CrossProcessSemaphoreDescriptor& aOther)
4908 : {
4909 33 : new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor(aOther);
4910 33 : mType = TCrossProcessSemaphoreDescriptor;
4911 33 : }
4912 :
4913 0 : MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const uintptr_t& aOther)
4914 : {
4915 0 : new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t(aOther);
4916 0 : mType = Tuintptr_t;
4917 0 : }
4918 :
4919 0 : MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const null_t& aOther)
4920 : {
4921 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
4922 0 : mType = Tnull_t;
4923 0 : }
4924 :
4925 0 : MOZ_IMPLICIT ReadLockDescriptor::ReadLockDescriptor(const ReadLockDescriptor& aOther)
4926 : {
4927 0 : (aOther).AssertSanity();
4928 0 : switch ((aOther).type()) {
4929 : case TShmemSection:
4930 : {
4931 0 : new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection((aOther).get_ShmemSection());
4932 0 : break;
4933 : }
4934 : case TCrossProcessSemaphoreDescriptor:
4935 : {
4936 0 : new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor((aOther).get_CrossProcessSemaphoreDescriptor());
4937 0 : break;
4938 : }
4939 : case Tuintptr_t:
4940 : {
4941 0 : new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t((aOther).get_uintptr_t());
4942 0 : break;
4943 : }
4944 : case Tnull_t:
4945 : {
4946 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
4947 0 : break;
4948 : }
4949 : case T__None:
4950 : {
4951 0 : break;
4952 : }
4953 : default:
4954 : {
4955 0 : mozilla::ipc::LogicError("unreached");
4956 0 : return;
4957 : }
4958 : }
4959 0 : mType = (aOther).type();
4960 : }
4961 :
4962 330 : ReadLockDescriptor::~ReadLockDescriptor()
4963 : {
4964 165 : static_cast<void>(MaybeDestroy(T__None));
4965 165 : }
4966 :
4967 0 : auto ReadLockDescriptor::operator=(const ShmemSection& aRhs) -> ReadLockDescriptor&
4968 : {
4969 0 : if (MaybeDestroy(TShmemSection)) {
4970 0 : new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection;
4971 : }
4972 0 : (*(ptr_ShmemSection())) = aRhs;
4973 0 : mType = TShmemSection;
4974 0 : return (*(this));
4975 : }
4976 :
4977 33 : auto ReadLockDescriptor::operator=(const CrossProcessSemaphoreDescriptor& aRhs) -> ReadLockDescriptor&
4978 : {
4979 33 : if (MaybeDestroy(TCrossProcessSemaphoreDescriptor)) {
4980 33 : new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor;
4981 : }
4982 33 : (*(ptr_CrossProcessSemaphoreDescriptor())) = aRhs;
4983 33 : mType = TCrossProcessSemaphoreDescriptor;
4984 33 : return (*(this));
4985 : }
4986 :
4987 0 : auto ReadLockDescriptor::operator=(const uintptr_t& aRhs) -> ReadLockDescriptor&
4988 : {
4989 0 : if (MaybeDestroy(Tuintptr_t)) {
4990 0 : new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
4991 : }
4992 0 : (*(ptr_uintptr_t())) = aRhs;
4993 0 : mType = Tuintptr_t;
4994 0 : return (*(this));
4995 : }
4996 :
4997 0 : auto ReadLockDescriptor::operator=(const null_t& aRhs) -> ReadLockDescriptor&
4998 : {
4999 0 : if (MaybeDestroy(Tnull_t)) {
5000 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
5001 : }
5002 0 : (*(ptr_null_t())) = aRhs;
5003 0 : mType = Tnull_t;
5004 0 : return (*(this));
5005 : }
5006 :
5007 99 : auto ReadLockDescriptor::operator=(const ReadLockDescriptor& aRhs) -> ReadLockDescriptor&
5008 : {
5009 99 : (aRhs).AssertSanity();
5010 99 : Type t = (aRhs).type();
5011 99 : switch (t) {
5012 : case TShmemSection:
5013 : {
5014 0 : if (MaybeDestroy(t)) {
5015 0 : new (mozilla::KnownNotNull, ptr_ShmemSection()) ShmemSection;
5016 : }
5017 0 : (*(ptr_ShmemSection())) = (aRhs).get_ShmemSection();
5018 0 : break;
5019 : }
5020 : case TCrossProcessSemaphoreDescriptor:
5021 : {
5022 99 : if (MaybeDestroy(t)) {
5023 99 : new (mozilla::KnownNotNull, ptr_CrossProcessSemaphoreDescriptor()) CrossProcessSemaphoreDescriptor;
5024 : }
5025 99 : (*(ptr_CrossProcessSemaphoreDescriptor())) = (aRhs).get_CrossProcessSemaphoreDescriptor();
5026 99 : break;
5027 : }
5028 : case Tuintptr_t:
5029 : {
5030 0 : if (MaybeDestroy(t)) {
5031 0 : new (mozilla::KnownNotNull, ptr_uintptr_t()) uintptr_t;
5032 : }
5033 0 : (*(ptr_uintptr_t())) = (aRhs).get_uintptr_t();
5034 0 : break;
5035 : }
5036 : case Tnull_t:
5037 : {
5038 0 : if (MaybeDestroy(t)) {
5039 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
5040 : }
5041 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
5042 0 : break;
5043 : }
5044 : case T__None:
5045 : {
5046 0 : static_cast<void>(MaybeDestroy(t));
5047 0 : break;
5048 : }
5049 : default:
5050 : {
5051 0 : mozilla::ipc::LogicError("unreached");
5052 0 : break;
5053 : }
5054 : }
5055 99 : mType = t;
5056 99 : return (*(this));
5057 : }
5058 :
5059 0 : auto ReadLockDescriptor::operator==(const ShmemSection& aRhs) const -> bool
5060 : {
5061 0 : return (get_ShmemSection()) == (aRhs);
5062 : }
5063 :
5064 0 : auto ReadLockDescriptor::operator==(const CrossProcessSemaphoreDescriptor& aRhs) const -> bool
5065 : {
5066 0 : return (get_CrossProcessSemaphoreDescriptor()) == (aRhs);
5067 : }
5068 :
5069 0 : auto ReadLockDescriptor::operator==(const uintptr_t& aRhs) const -> bool
5070 : {
5071 0 : return (get_uintptr_t()) == (aRhs);
5072 : }
5073 :
5074 0 : auto ReadLockDescriptor::operator==(const null_t& aRhs) const -> bool
5075 : {
5076 0 : return (get_null_t()) == (aRhs);
5077 : }
5078 :
5079 0 : auto ReadLockDescriptor::operator==(const ReadLockDescriptor& aRhs) const -> bool
5080 : {
5081 0 : if ((type()) != ((aRhs).type())) {
5082 0 : return false;
5083 : }
5084 :
5085 0 : switch (type()) {
5086 : case TShmemSection:
5087 : {
5088 0 : return (get_ShmemSection()) == ((aRhs).get_ShmemSection());
5089 : }
5090 : case TCrossProcessSemaphoreDescriptor:
5091 : {
5092 0 : return (get_CrossProcessSemaphoreDescriptor()) == ((aRhs).get_CrossProcessSemaphoreDescriptor());
5093 : }
5094 : case Tuintptr_t:
5095 : {
5096 0 : return (get_uintptr_t()) == ((aRhs).get_uintptr_t());
5097 : }
5098 : case Tnull_t:
5099 : {
5100 0 : return (get_null_t()) == ((aRhs).get_null_t());
5101 : }
5102 : default:
5103 : {
5104 0 : mozilla::ipc::LogicError("unreached");
5105 0 : return false;
5106 : }
5107 : }
5108 : }
5109 :
5110 0 : auto ReadLockDescriptor::get(ShmemSection* aOutValue) const -> void
5111 : {
5112 0 : (*(aOutValue)) = get_ShmemSection();
5113 0 : }
5114 :
5115 0 : auto ReadLockDescriptor::get(CrossProcessSemaphoreDescriptor* aOutValue) const -> void
5116 : {
5117 0 : (*(aOutValue)) = get_CrossProcessSemaphoreDescriptor();
5118 0 : }
5119 :
5120 0 : auto ReadLockDescriptor::get(uintptr_t* aOutValue) const -> void
5121 : {
5122 0 : (*(aOutValue)) = get_uintptr_t();
5123 0 : }
5124 :
5125 0 : auto ReadLockDescriptor::get(null_t* aOutValue) const -> void
5126 : {
5127 0 : (*(aOutValue)) = get_null_t();
5128 0 : }
5129 :
5130 : } // namespace layers
5131 : } // namespace mozilla
5132 :
5133 : //-----------------------------------------------------------------------------
5134 : // Method definitions for the IPDL type |struct ReadLockInit|
5135 : //
5136 : namespace mozilla {
5137 : namespace layers {
5138 33 : MOZ_IMPLICIT ReadLockInit::ReadLockInit() :
5139 33 : handle_()
5140 : {
5141 33 : Init();
5142 33 : }
5143 :
5144 99 : ReadLockInit::~ReadLockInit()
5145 : {
5146 99 : }
5147 :
5148 0 : auto ReadLockInit::operator==(const ReadLockInit& _o) const -> bool
5149 : {
5150 0 : if ((!((sharedLock()) == ((_o).sharedLock())))) {
5151 0 : return false;
5152 : }
5153 0 : if ((!((handle()) == ((_o).handle())))) {
5154 0 : return false;
5155 : }
5156 0 : return true;
5157 : }
5158 :
5159 0 : auto ReadLockInit::operator!=(const ReadLockInit& _o) const -> bool
5160 : {
5161 0 : return (!(operator==(_o)));
5162 : }
5163 :
5164 99 : auto ReadLockInit::Init() -> void
5165 : {
5166 99 : }
5167 :
5168 66 : auto ReadLockInit::Assign(
5169 : const ReadLockDescriptor& _sharedLock,
5170 : const ReadLockHandle& _handle) -> void
5171 : {
5172 66 : sharedLock_ = _sharedLock;
5173 66 : handle_ = _handle;
5174 66 : }
5175 :
5176 : } // namespace layers
5177 : } // namespace mozilla
5178 :
5179 : //-----------------------------------------------------------------------------
5180 : // Method definitions for the IPDL type |union MaybeTexture|
5181 : //
5182 : namespace mozilla {
5183 : namespace layers {
5184 0 : auto MaybeTexture::MaybeDestroy(Type aNewType) -> bool
5185 : {
5186 0 : if ((mType) == (T__None)) {
5187 0 : return true;
5188 : }
5189 0 : if ((mType) == (aNewType)) {
5190 0 : return false;
5191 : }
5192 0 : switch (mType) {
5193 : case TPTextureParent:
5194 : {
5195 0 : (ptr_PTextureParent())->~PTextureParent__tdef();
5196 0 : break;
5197 : }
5198 : case TPTextureChild:
5199 : {
5200 0 : (ptr_PTextureChild())->~PTextureChild__tdef();
5201 0 : break;
5202 : }
5203 : case Tnull_t:
5204 : {
5205 0 : (ptr_null_t())->~null_t__tdef();
5206 0 : break;
5207 : }
5208 : default:
5209 : {
5210 0 : mozilla::ipc::LogicError("not reached");
5211 0 : break;
5212 : }
5213 : }
5214 0 : return true;
5215 : }
5216 :
5217 0 : MOZ_IMPLICIT MaybeTexture::MaybeTexture(PTextureParent* aOther)
5218 : {
5219 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(aOther));
5220 0 : mType = TPTextureParent;
5221 0 : }
5222 :
5223 0 : MOZ_IMPLICIT MaybeTexture::MaybeTexture(PTextureChild* aOther)
5224 : {
5225 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(aOther));
5226 0 : mType = TPTextureChild;
5227 0 : }
5228 :
5229 0 : MOZ_IMPLICIT MaybeTexture::MaybeTexture(const null_t& aOther)
5230 : {
5231 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
5232 0 : mType = Tnull_t;
5233 0 : }
5234 :
5235 0 : MOZ_IMPLICIT MaybeTexture::MaybeTexture(const MaybeTexture& aOther)
5236 : {
5237 0 : (aOther).AssertSanity();
5238 0 : switch ((aOther).type()) {
5239 : case TPTextureParent:
5240 : {
5241 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>((aOther).get_PTextureParent()));
5242 0 : break;
5243 : }
5244 : case TPTextureChild:
5245 : {
5246 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>((aOther).get_PTextureChild()));
5247 0 : break;
5248 : }
5249 : case Tnull_t:
5250 : {
5251 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
5252 0 : break;
5253 : }
5254 : case T__None:
5255 : {
5256 0 : break;
5257 : }
5258 : default:
5259 : {
5260 0 : mozilla::ipc::LogicError("unreached");
5261 0 : return;
5262 : }
5263 : }
5264 0 : mType = (aOther).type();
5265 : }
5266 :
5267 0 : MaybeTexture::~MaybeTexture()
5268 : {
5269 0 : static_cast<void>(MaybeDestroy(T__None));
5270 0 : }
5271 :
5272 0 : auto MaybeTexture::operator=(PTextureParent* aRhs) -> MaybeTexture&
5273 : {
5274 0 : if (MaybeDestroy(TPTextureParent)) {
5275 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
5276 : }
5277 0 : (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(aRhs);
5278 0 : mType = TPTextureParent;
5279 0 : return (*(this));
5280 : }
5281 :
5282 0 : auto MaybeTexture::operator=(PTextureChild* aRhs) -> MaybeTexture&
5283 : {
5284 0 : if (MaybeDestroy(TPTextureChild)) {
5285 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
5286 : }
5287 0 : (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(aRhs);
5288 0 : mType = TPTextureChild;
5289 0 : return (*(this));
5290 : }
5291 :
5292 0 : auto MaybeTexture::operator=(const null_t& aRhs) -> MaybeTexture&
5293 : {
5294 0 : if (MaybeDestroy(Tnull_t)) {
5295 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
5296 : }
5297 0 : (*(ptr_null_t())) = aRhs;
5298 0 : mType = Tnull_t;
5299 0 : return (*(this));
5300 : }
5301 :
5302 0 : auto MaybeTexture::operator=(const MaybeTexture& aRhs) -> MaybeTexture&
5303 : {
5304 0 : (aRhs).AssertSanity();
5305 0 : Type t = (aRhs).type();
5306 0 : switch (t) {
5307 : case TPTextureParent:
5308 : {
5309 0 : if (MaybeDestroy(t)) {
5310 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
5311 : }
5312 0 : (*(ptr_PTextureParent())) = const_cast<PTextureParent*>((aRhs).get_PTextureParent());
5313 0 : break;
5314 : }
5315 : case TPTextureChild:
5316 : {
5317 0 : if (MaybeDestroy(t)) {
5318 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
5319 : }
5320 0 : (*(ptr_PTextureChild())) = const_cast<PTextureChild*>((aRhs).get_PTextureChild());
5321 0 : break;
5322 : }
5323 : case Tnull_t:
5324 : {
5325 0 : if (MaybeDestroy(t)) {
5326 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
5327 : }
5328 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
5329 0 : break;
5330 : }
5331 : case T__None:
5332 : {
5333 0 : static_cast<void>(MaybeDestroy(t));
5334 0 : break;
5335 : }
5336 : default:
5337 : {
5338 0 : mozilla::ipc::LogicError("unreached");
5339 0 : break;
5340 : }
5341 : }
5342 0 : mType = t;
5343 0 : return (*(this));
5344 : }
5345 :
5346 0 : auto MaybeTexture::operator==(PTextureParent* aRhs) const -> bool
5347 : {
5348 0 : return (get_PTextureParent()) == (aRhs);
5349 : }
5350 :
5351 0 : auto MaybeTexture::operator==(PTextureChild* aRhs) const -> bool
5352 : {
5353 0 : return (get_PTextureChild()) == (aRhs);
5354 : }
5355 :
5356 0 : auto MaybeTexture::operator==(const null_t& aRhs) const -> bool
5357 : {
5358 0 : return (get_null_t()) == (aRhs);
5359 : }
5360 :
5361 0 : auto MaybeTexture::operator==(const MaybeTexture& aRhs) const -> bool
5362 : {
5363 0 : if ((type()) != ((aRhs).type())) {
5364 0 : return false;
5365 : }
5366 :
5367 0 : switch (type()) {
5368 : case TPTextureParent:
5369 : {
5370 0 : return (get_PTextureParent()) == ((aRhs).get_PTextureParent());
5371 : }
5372 : case TPTextureChild:
5373 : {
5374 0 : return (get_PTextureChild()) == ((aRhs).get_PTextureChild());
5375 : }
5376 : case Tnull_t:
5377 : {
5378 0 : return (get_null_t()) == ((aRhs).get_null_t());
5379 : }
5380 : default:
5381 : {
5382 0 : mozilla::ipc::LogicError("unreached");
5383 0 : return false;
5384 : }
5385 : }
5386 : }
5387 :
5388 0 : auto MaybeTexture::get(PTextureParent** aOutValue) const -> void
5389 : {
5390 0 : (*(aOutValue)) = get_PTextureParent();
5391 0 : }
5392 :
5393 0 : auto MaybeTexture::get(PTextureChild** aOutValue) const -> void
5394 : {
5395 0 : (*(aOutValue)) = get_PTextureChild();
5396 0 : }
5397 :
5398 0 : auto MaybeTexture::get(null_t* aOutValue) const -> void
5399 : {
5400 0 : (*(aOutValue)) = get_null_t();
5401 0 : }
5402 :
5403 : } // namespace layers
5404 : } // namespace mozilla
5405 :
5406 : //-----------------------------------------------------------------------------
5407 : // Method definitions for the IPDL type |struct TexturedTileDescriptor|
5408 : //
5409 : namespace mozilla {
5410 : namespace layers {
5411 0 : MOZ_IMPLICIT TexturedTileDescriptor::TexturedTileDescriptor() :
5412 : updateRect_(),
5413 0 : wasPlaceholder_()
5414 : {
5415 0 : Init();
5416 0 : }
5417 :
5418 0 : TexturedTileDescriptor::~TexturedTileDescriptor()
5419 : {
5420 0 : }
5421 :
5422 0 : auto TexturedTileDescriptor::operator==(const TexturedTileDescriptor& _o) const -> bool
5423 : {
5424 0 : if ((!((textureParent()) == ((_o).textureParent())))) {
5425 0 : return false;
5426 : }
5427 0 : if ((!((textureChild()) == ((_o).textureChild())))) {
5428 0 : return false;
5429 : }
5430 0 : if ((!((textureOnWhite()) == ((_o).textureOnWhite())))) {
5431 0 : return false;
5432 : }
5433 0 : if ((!((updateRect()) == ((_o).updateRect())))) {
5434 0 : return false;
5435 : }
5436 0 : if ((!((sharedLock()) == ((_o).sharedLock())))) {
5437 0 : return false;
5438 : }
5439 0 : if ((!((sharedLockOnWhite()) == ((_o).sharedLockOnWhite())))) {
5440 0 : return false;
5441 : }
5442 0 : if ((!((wasPlaceholder()) == ((_o).wasPlaceholder())))) {
5443 0 : return false;
5444 : }
5445 0 : return true;
5446 : }
5447 :
5448 0 : auto TexturedTileDescriptor::operator!=(const TexturedTileDescriptor& _o) const -> bool
5449 : {
5450 0 : return (!(operator==(_o)));
5451 : }
5452 :
5453 0 : auto TexturedTileDescriptor::Init() -> void
5454 : {
5455 0 : textureParent_ = nullptr;
5456 0 : textureChild_ = nullptr;
5457 0 : }
5458 :
5459 0 : auto TexturedTileDescriptor::Assign(
5460 : PTextureParent* _textureParent,
5461 : PTextureChild* _textureChild,
5462 : const MaybeTexture& _textureOnWhite,
5463 : const IntRect& _updateRect,
5464 : const ReadLockDescriptor& _sharedLock,
5465 : const ReadLockDescriptor& _sharedLockOnWhite,
5466 : const bool& _wasPlaceholder) -> void
5467 : {
5468 0 : textureParent_ = _textureParent;
5469 0 : textureChild_ = _textureChild;
5470 0 : textureOnWhite_ = _textureOnWhite;
5471 0 : updateRect_ = _updateRect;
5472 0 : sharedLock_ = _sharedLock;
5473 0 : sharedLockOnWhite_ = _sharedLockOnWhite;
5474 0 : wasPlaceholder_ = _wasPlaceholder;
5475 0 : }
5476 :
5477 : } // namespace layers
5478 : } // namespace mozilla
5479 :
5480 : //-----------------------------------------------------------------------------
5481 : // Method definitions for the IPDL type |struct PlaceholderTileDescriptor|
5482 : //
5483 : namespace mozilla {
5484 : namespace layers {
5485 0 : PlaceholderTileDescriptor::~PlaceholderTileDescriptor()
5486 : {
5487 0 : }
5488 :
5489 0 : auto PlaceholderTileDescriptor::operator==(const PlaceholderTileDescriptor& _o) const -> bool
5490 : {
5491 0 : return true;
5492 : }
5493 :
5494 0 : auto PlaceholderTileDescriptor::operator!=(const PlaceholderTileDescriptor& _o) const -> bool
5495 : {
5496 0 : return (!(operator==(_o)));
5497 : }
5498 :
5499 0 : auto PlaceholderTileDescriptor::Init() -> void
5500 : {
5501 0 : }
5502 :
5503 0 : auto PlaceholderTileDescriptor::Assign() -> void
5504 : {
5505 0 : }
5506 :
5507 : } // namespace layers
5508 : } // namespace mozilla
5509 :
5510 : //-----------------------------------------------------------------------------
5511 : // Method definitions for the IPDL type |union TileDescriptor|
5512 : //
5513 : namespace mozilla {
5514 : namespace layers {
5515 0 : auto TileDescriptor::MaybeDestroy(Type aNewType) -> bool
5516 : {
5517 0 : if ((mType) == (T__None)) {
5518 0 : return true;
5519 : }
5520 0 : if ((mType) == (aNewType)) {
5521 0 : return false;
5522 : }
5523 0 : switch (mType) {
5524 : case TTexturedTileDescriptor:
5525 : {
5526 0 : (ptr_TexturedTileDescriptor())->~TexturedTileDescriptor__tdef();
5527 0 : break;
5528 : }
5529 : case TPlaceholderTileDescriptor:
5530 : {
5531 0 : (ptr_PlaceholderTileDescriptor())->~PlaceholderTileDescriptor__tdef();
5532 0 : break;
5533 : }
5534 : default:
5535 : {
5536 0 : mozilla::ipc::LogicError("not reached");
5537 0 : break;
5538 : }
5539 : }
5540 0 : return true;
5541 : }
5542 :
5543 0 : MOZ_IMPLICIT TileDescriptor::TileDescriptor(const TexturedTileDescriptor& aOther)
5544 : {
5545 0 : new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor(aOther);
5546 0 : mType = TTexturedTileDescriptor;
5547 0 : }
5548 :
5549 0 : MOZ_IMPLICIT TileDescriptor::TileDescriptor(const PlaceholderTileDescriptor& aOther)
5550 : {
5551 0 : new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor(aOther);
5552 0 : mType = TPlaceholderTileDescriptor;
5553 0 : }
5554 :
5555 0 : MOZ_IMPLICIT TileDescriptor::TileDescriptor(const TileDescriptor& aOther)
5556 : {
5557 0 : (aOther).AssertSanity();
5558 0 : switch ((aOther).type()) {
5559 : case TTexturedTileDescriptor:
5560 : {
5561 0 : new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor((aOther).get_TexturedTileDescriptor());
5562 0 : break;
5563 : }
5564 : case TPlaceholderTileDescriptor:
5565 : {
5566 0 : new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor((aOther).get_PlaceholderTileDescriptor());
5567 0 : break;
5568 : }
5569 : case T__None:
5570 : {
5571 0 : break;
5572 : }
5573 : default:
5574 : {
5575 0 : mozilla::ipc::LogicError("unreached");
5576 0 : return;
5577 : }
5578 : }
5579 0 : mType = (aOther).type();
5580 : }
5581 :
5582 0 : TileDescriptor::~TileDescriptor()
5583 : {
5584 0 : static_cast<void>(MaybeDestroy(T__None));
5585 0 : }
5586 :
5587 0 : auto TileDescriptor::operator=(const TexturedTileDescriptor& aRhs) -> TileDescriptor&
5588 : {
5589 0 : if (MaybeDestroy(TTexturedTileDescriptor)) {
5590 0 : new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
5591 : }
5592 0 : (*(ptr_TexturedTileDescriptor())) = aRhs;
5593 0 : mType = TTexturedTileDescriptor;
5594 0 : return (*(this));
5595 : }
5596 :
5597 0 : auto TileDescriptor::operator=(const PlaceholderTileDescriptor& aRhs) -> TileDescriptor&
5598 : {
5599 0 : if (MaybeDestroy(TPlaceholderTileDescriptor)) {
5600 0 : new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
5601 : }
5602 0 : (*(ptr_PlaceholderTileDescriptor())) = aRhs;
5603 0 : mType = TPlaceholderTileDescriptor;
5604 0 : return (*(this));
5605 : }
5606 :
5607 0 : auto TileDescriptor::operator=(const TileDescriptor& aRhs) -> TileDescriptor&
5608 : {
5609 0 : (aRhs).AssertSanity();
5610 0 : Type t = (aRhs).type();
5611 0 : switch (t) {
5612 : case TTexturedTileDescriptor:
5613 : {
5614 0 : if (MaybeDestroy(t)) {
5615 0 : new (mozilla::KnownNotNull, ptr_TexturedTileDescriptor()) TexturedTileDescriptor;
5616 : }
5617 0 : (*(ptr_TexturedTileDescriptor())) = (aRhs).get_TexturedTileDescriptor();
5618 0 : break;
5619 : }
5620 : case TPlaceholderTileDescriptor:
5621 : {
5622 0 : if (MaybeDestroy(t)) {
5623 0 : new (mozilla::KnownNotNull, ptr_PlaceholderTileDescriptor()) PlaceholderTileDescriptor;
5624 : }
5625 0 : (*(ptr_PlaceholderTileDescriptor())) = (aRhs).get_PlaceholderTileDescriptor();
5626 0 : break;
5627 : }
5628 : case T__None:
5629 : {
5630 0 : static_cast<void>(MaybeDestroy(t));
5631 0 : break;
5632 : }
5633 : default:
5634 : {
5635 0 : mozilla::ipc::LogicError("unreached");
5636 0 : break;
5637 : }
5638 : }
5639 0 : mType = t;
5640 0 : return (*(this));
5641 : }
5642 :
5643 0 : auto TileDescriptor::operator==(const TexturedTileDescriptor& aRhs) const -> bool
5644 : {
5645 0 : return (get_TexturedTileDescriptor()) == (aRhs);
5646 : }
5647 :
5648 0 : auto TileDescriptor::operator==(const PlaceholderTileDescriptor& aRhs) const -> bool
5649 : {
5650 0 : return (get_PlaceholderTileDescriptor()) == (aRhs);
5651 : }
5652 :
5653 0 : auto TileDescriptor::operator==(const TileDescriptor& aRhs) const -> bool
5654 : {
5655 0 : if ((type()) != ((aRhs).type())) {
5656 0 : return false;
5657 : }
5658 :
5659 0 : switch (type()) {
5660 : case TTexturedTileDescriptor:
5661 : {
5662 0 : return (get_TexturedTileDescriptor()) == ((aRhs).get_TexturedTileDescriptor());
5663 : }
5664 : case TPlaceholderTileDescriptor:
5665 : {
5666 0 : return (get_PlaceholderTileDescriptor()) == ((aRhs).get_PlaceholderTileDescriptor());
5667 : }
5668 : default:
5669 : {
5670 0 : mozilla::ipc::LogicError("unreached");
5671 0 : return false;
5672 : }
5673 : }
5674 : }
5675 :
5676 0 : auto TileDescriptor::get(TexturedTileDescriptor* aOutValue) const -> void
5677 : {
5678 0 : (*(aOutValue)) = get_TexturedTileDescriptor();
5679 0 : }
5680 :
5681 0 : auto TileDescriptor::get(PlaceholderTileDescriptor* aOutValue) const -> void
5682 : {
5683 0 : (*(aOutValue)) = get_PlaceholderTileDescriptor();
5684 0 : }
5685 :
5686 : } // namespace layers
5687 : } // namespace mozilla
5688 :
5689 : //-----------------------------------------------------------------------------
5690 : // Method definitions for the IPDL type |struct SurfaceDescriptorTiles|
5691 : //
5692 : namespace mozilla {
5693 : namespace layers {
5694 0 : MOZ_IMPLICIT SurfaceDescriptorTiles::SurfaceDescriptorTiles() :
5695 : validRegion_(),
5696 : tileOrigin_(),
5697 : tileSize_(),
5698 : firstTileX_(),
5699 : firstTileY_(),
5700 : retainedWidth_(),
5701 : retainedHeight_(),
5702 : resolution_(),
5703 : frameXResolution_(),
5704 : frameYResolution_(),
5705 0 : isProgressive_()
5706 : {
5707 0 : Init();
5708 0 : }
5709 :
5710 0 : SurfaceDescriptorTiles::~SurfaceDescriptorTiles()
5711 : {
5712 0 : }
5713 :
5714 0 : auto SurfaceDescriptorTiles::operator==(const SurfaceDescriptorTiles& _o) const -> bool
5715 : {
5716 0 : if ((!((validRegion()) == ((_o).validRegion())))) {
5717 0 : return false;
5718 : }
5719 0 : if ((!((tiles()) == ((_o).tiles())))) {
5720 0 : return false;
5721 : }
5722 0 : if ((!((tileOrigin()) == ((_o).tileOrigin())))) {
5723 0 : return false;
5724 : }
5725 0 : if ((!((tileSize()) == ((_o).tileSize())))) {
5726 0 : return false;
5727 : }
5728 0 : if ((!((firstTileX()) == ((_o).firstTileX())))) {
5729 0 : return false;
5730 : }
5731 0 : if ((!((firstTileY()) == ((_o).firstTileY())))) {
5732 0 : return false;
5733 : }
5734 0 : if ((!((retainedWidth()) == ((_o).retainedWidth())))) {
5735 0 : return false;
5736 : }
5737 0 : if ((!((retainedHeight()) == ((_o).retainedHeight())))) {
5738 0 : return false;
5739 : }
5740 0 : if ((!((resolution()) == ((_o).resolution())))) {
5741 0 : return false;
5742 : }
5743 0 : if ((!((frameXResolution()) == ((_o).frameXResolution())))) {
5744 0 : return false;
5745 : }
5746 0 : if ((!((frameYResolution()) == ((_o).frameYResolution())))) {
5747 0 : return false;
5748 : }
5749 0 : if ((!((isProgressive()) == ((_o).isProgressive())))) {
5750 0 : return false;
5751 : }
5752 0 : return true;
5753 : }
5754 :
5755 0 : auto SurfaceDescriptorTiles::operator!=(const SurfaceDescriptorTiles& _o) const -> bool
5756 : {
5757 0 : return (!(operator==(_o)));
5758 : }
5759 :
5760 0 : auto SurfaceDescriptorTiles::Init() -> void
5761 : {
5762 0 : }
5763 :
5764 0 : auto SurfaceDescriptorTiles::Assign(
5765 : const nsIntRegion& _validRegion,
5766 : const nsTArray<TileDescriptor>& _tiles,
5767 : const IntPoint& _tileOrigin,
5768 : const IntSize& _tileSize,
5769 : const int& _firstTileX,
5770 : const int& _firstTileY,
5771 : const int& _retainedWidth,
5772 : const int& _retainedHeight,
5773 : const float& _resolution,
5774 : const float& _frameXResolution,
5775 : const float& _frameYResolution,
5776 : const bool& _isProgressive) -> void
5777 : {
5778 0 : validRegion_ = _validRegion;
5779 0 : tiles_ = _tiles;
5780 0 : tileOrigin_ = _tileOrigin;
5781 0 : tileSize_ = _tileSize;
5782 0 : firstTileX_ = _firstTileX;
5783 0 : firstTileY_ = _firstTileY;
5784 0 : retainedWidth_ = _retainedWidth;
5785 0 : retainedHeight_ = _retainedHeight;
5786 0 : resolution_ = _resolution;
5787 0 : frameXResolution_ = _frameXResolution;
5788 0 : frameYResolution_ = _frameYResolution;
5789 0 : isProgressive_ = _isProgressive;
5790 0 : }
5791 :
5792 : } // namespace layers
5793 : } // namespace mozilla
5794 :
5795 : //-----------------------------------------------------------------------------
5796 : // Method definitions for the IPDL type |struct OpUseTiledLayerBuffer|
5797 : //
5798 : namespace mozilla {
5799 : namespace layers {
5800 0 : MOZ_IMPLICIT OpUseTiledLayerBuffer::OpUseTiledLayerBuffer()
5801 : {
5802 0 : Init();
5803 0 : }
5804 :
5805 0 : OpUseTiledLayerBuffer::~OpUseTiledLayerBuffer()
5806 : {
5807 0 : }
5808 :
5809 0 : auto OpUseTiledLayerBuffer::operator==(const OpUseTiledLayerBuffer& _o) const -> bool
5810 : {
5811 0 : if ((!((tileLayerDescriptor()) == ((_o).tileLayerDescriptor())))) {
5812 0 : return false;
5813 : }
5814 0 : return true;
5815 : }
5816 :
5817 0 : auto OpUseTiledLayerBuffer::operator!=(const OpUseTiledLayerBuffer& _o) const -> bool
5818 : {
5819 0 : return (!(operator==(_o)));
5820 : }
5821 :
5822 0 : auto OpUseTiledLayerBuffer::Init() -> void
5823 : {
5824 0 : }
5825 :
5826 0 : auto OpUseTiledLayerBuffer::Assign(const SurfaceDescriptorTiles& _tileLayerDescriptor) -> void
5827 : {
5828 0 : tileLayerDescriptor_ = _tileLayerDescriptor;
5829 0 : }
5830 :
5831 : } // namespace layers
5832 : } // namespace mozilla
5833 :
5834 : //-----------------------------------------------------------------------------
5835 : // Method definitions for the IPDL type |struct OpPaintTextureRegion|
5836 : //
5837 : namespace mozilla {
5838 : namespace layers {
5839 165 : MOZ_IMPLICIT OpPaintTextureRegion::OpPaintTextureRegion() :
5840 165 : updatedRegion_()
5841 : {
5842 165 : Init();
5843 165 : }
5844 :
5845 231 : OpPaintTextureRegion::~OpPaintTextureRegion()
5846 : {
5847 231 : }
5848 :
5849 0 : auto OpPaintTextureRegion::operator==(const OpPaintTextureRegion& _o) const -> bool
5850 : {
5851 0 : if ((!((bufferData()) == ((_o).bufferData())))) {
5852 0 : return false;
5853 : }
5854 0 : if ((!((updatedRegion()) == ((_o).updatedRegion())))) {
5855 0 : return false;
5856 : }
5857 0 : return true;
5858 : }
5859 :
5860 0 : auto OpPaintTextureRegion::operator!=(const OpPaintTextureRegion& _o) const -> bool
5861 : {
5862 0 : return (!(operator==(_o)));
5863 : }
5864 :
5865 231 : auto OpPaintTextureRegion::Init() -> void
5866 : {
5867 231 : }
5868 :
5869 198 : auto OpPaintTextureRegion::Assign(
5870 : const ThebesBufferData& _bufferData,
5871 : const nsIntRegion& _updatedRegion) -> void
5872 : {
5873 198 : bufferData_ = _bufferData;
5874 198 : updatedRegion_ = _updatedRegion;
5875 198 : }
5876 :
5877 : } // namespace layers
5878 : } // namespace mozilla
5879 :
5880 : //-----------------------------------------------------------------------------
5881 : // Method definitions for the IPDL type |struct OpRemoveTexture|
5882 : //
5883 : namespace mozilla {
5884 : namespace layers {
5885 0 : MOZ_IMPLICIT OpRemoveTexture::OpRemoveTexture()
5886 : {
5887 0 : Init();
5888 0 : }
5889 :
5890 0 : OpRemoveTexture::~OpRemoveTexture()
5891 : {
5892 0 : }
5893 :
5894 0 : auto OpRemoveTexture::operator==(const OpRemoveTexture& _o) const -> bool
5895 : {
5896 0 : if ((!((textureParent()) == ((_o).textureParent())))) {
5897 0 : return false;
5898 : }
5899 0 : if ((!((textureChild()) == ((_o).textureChild())))) {
5900 0 : return false;
5901 : }
5902 0 : return true;
5903 : }
5904 :
5905 0 : auto OpRemoveTexture::operator!=(const OpRemoveTexture& _o) const -> bool
5906 : {
5907 0 : return (!(operator==(_o)));
5908 : }
5909 :
5910 0 : auto OpRemoveTexture::Init() -> void
5911 : {
5912 0 : textureParent_ = nullptr;
5913 0 : textureChild_ = nullptr;
5914 0 : }
5915 :
5916 0 : auto OpRemoveTexture::Assign(
5917 : PTextureParent* _textureParent,
5918 : PTextureChild* _textureChild) -> void
5919 : {
5920 0 : textureParent_ = _textureParent;
5921 0 : textureChild_ = _textureChild;
5922 0 : }
5923 :
5924 : } // namespace layers
5925 : } // namespace mozilla
5926 :
5927 : //-----------------------------------------------------------------------------
5928 : // Method definitions for the IPDL type |struct TimedTexture|
5929 : //
5930 : namespace mozilla {
5931 : namespace layers {
5932 33 : MOZ_IMPLICIT TimedTexture::TimedTexture() :
5933 : sharedLock_(),
5934 : timeStamp_(),
5935 : picture_(),
5936 : frameID_(),
5937 33 : producerID_()
5938 : {
5939 33 : Init();
5940 33 : }
5941 :
5942 264 : TimedTexture::~TimedTexture()
5943 : {
5944 264 : }
5945 :
5946 0 : auto TimedTexture::operator==(const TimedTexture& _o) const -> bool
5947 : {
5948 0 : if ((!((textureParent()) == ((_o).textureParent())))) {
5949 0 : return false;
5950 : }
5951 0 : if ((!((textureChild()) == ((_o).textureChild())))) {
5952 0 : return false;
5953 : }
5954 0 : if ((!((sharedLock()) == ((_o).sharedLock())))) {
5955 0 : return false;
5956 : }
5957 0 : if ((!((timeStamp()) == ((_o).timeStamp())))) {
5958 0 : return false;
5959 : }
5960 0 : if ((!((picture()) == ((_o).picture())))) {
5961 0 : return false;
5962 : }
5963 0 : if ((!((frameID()) == ((_o).frameID())))) {
5964 0 : return false;
5965 : }
5966 0 : if ((!((producerID()) == ((_o).producerID())))) {
5967 0 : return false;
5968 : }
5969 0 : return true;
5970 : }
5971 :
5972 0 : auto TimedTexture::operator!=(const TimedTexture& _o) const -> bool
5973 : {
5974 0 : return (!(operator==(_o)));
5975 : }
5976 :
5977 264 : auto TimedTexture::Init() -> void
5978 : {
5979 264 : textureParent_ = nullptr;
5980 264 : textureChild_ = nullptr;
5981 264 : }
5982 :
5983 231 : auto TimedTexture::Assign(
5984 : PTextureParent* _textureParent,
5985 : PTextureChild* _textureChild,
5986 : const ReadLockHandle& _sharedLock,
5987 : const TimeStamp& _timeStamp,
5988 : const IntRect& _picture,
5989 : const uint32_t& _frameID,
5990 : const uint32_t& _producerID) -> void
5991 : {
5992 231 : textureParent_ = _textureParent;
5993 231 : textureChild_ = _textureChild;
5994 231 : sharedLock_ = _sharedLock;
5995 231 : timeStamp_ = _timeStamp;
5996 231 : picture_ = _picture;
5997 231 : frameID_ = _frameID;
5998 231 : producerID_ = _producerID;
5999 231 : }
6000 :
6001 : } // namespace layers
6002 : } // namespace mozilla
6003 :
6004 : //-----------------------------------------------------------------------------
6005 : // Method definitions for the IPDL type |struct OpUseTexture|
6006 : //
6007 : namespace mozilla {
6008 : namespace layers {
6009 165 : MOZ_IMPLICIT OpUseTexture::OpUseTexture()
6010 : {
6011 165 : Init();
6012 165 : }
6013 :
6014 231 : OpUseTexture::~OpUseTexture()
6015 : {
6016 231 : }
6017 :
6018 0 : auto OpUseTexture::operator==(const OpUseTexture& _o) const -> bool
6019 : {
6020 0 : if ((!((textures()) == ((_o).textures())))) {
6021 0 : return false;
6022 : }
6023 0 : return true;
6024 : }
6025 :
6026 0 : auto OpUseTexture::operator!=(const OpUseTexture& _o) const -> bool
6027 : {
6028 0 : return (!(operator==(_o)));
6029 : }
6030 :
6031 231 : auto OpUseTexture::Init() -> void
6032 : {
6033 231 : }
6034 :
6035 198 : auto OpUseTexture::Assign(const nsTArray<TimedTexture>& _textures) -> void
6036 : {
6037 198 : textures_ = _textures;
6038 198 : }
6039 :
6040 : } // namespace layers
6041 : } // namespace mozilla
6042 :
6043 : //-----------------------------------------------------------------------------
6044 : // Method definitions for the IPDL type |struct OpUseComponentAlphaTextures|
6045 : //
6046 : namespace mozilla {
6047 : namespace layers {
6048 0 : MOZ_IMPLICIT OpUseComponentAlphaTextures::OpUseComponentAlphaTextures() :
6049 : sharedLockBlack_(),
6050 0 : sharedLockWhite_()
6051 : {
6052 0 : Init();
6053 0 : }
6054 :
6055 0 : OpUseComponentAlphaTextures::~OpUseComponentAlphaTextures()
6056 : {
6057 0 : }
6058 :
6059 0 : auto OpUseComponentAlphaTextures::operator==(const OpUseComponentAlphaTextures& _o) const -> bool
6060 : {
6061 0 : if ((!((textureOnBlackParent()) == ((_o).textureOnBlackParent())))) {
6062 0 : return false;
6063 : }
6064 0 : if ((!((textureOnBlackChild()) == ((_o).textureOnBlackChild())))) {
6065 0 : return false;
6066 : }
6067 0 : if ((!((textureOnWhiteParent()) == ((_o).textureOnWhiteParent())))) {
6068 0 : return false;
6069 : }
6070 0 : if ((!((textureOnWhiteChild()) == ((_o).textureOnWhiteChild())))) {
6071 0 : return false;
6072 : }
6073 0 : if ((!((sharedLockBlack()) == ((_o).sharedLockBlack())))) {
6074 0 : return false;
6075 : }
6076 0 : if ((!((sharedLockWhite()) == ((_o).sharedLockWhite())))) {
6077 0 : return false;
6078 : }
6079 0 : return true;
6080 : }
6081 :
6082 0 : auto OpUseComponentAlphaTextures::operator!=(const OpUseComponentAlphaTextures& _o) const -> bool
6083 : {
6084 0 : return (!(operator==(_o)));
6085 : }
6086 :
6087 0 : auto OpUseComponentAlphaTextures::Init() -> void
6088 : {
6089 0 : textureOnBlackParent_ = nullptr;
6090 0 : textureOnBlackChild_ = nullptr;
6091 0 : textureOnWhiteParent_ = nullptr;
6092 0 : textureOnWhiteChild_ = nullptr;
6093 0 : }
6094 :
6095 0 : auto OpUseComponentAlphaTextures::Assign(
6096 : PTextureParent* _textureOnBlackParent,
6097 : PTextureChild* _textureOnBlackChild,
6098 : PTextureParent* _textureOnWhiteParent,
6099 : PTextureChild* _textureOnWhiteChild,
6100 : const ReadLockHandle& _sharedLockBlack,
6101 : const ReadLockHandle& _sharedLockWhite) -> void
6102 : {
6103 0 : textureOnBlackParent_ = _textureOnBlackParent;
6104 0 : textureOnBlackChild_ = _textureOnBlackChild;
6105 0 : textureOnWhiteParent_ = _textureOnWhiteParent;
6106 0 : textureOnWhiteChild_ = _textureOnWhiteChild;
6107 0 : sharedLockBlack_ = _sharedLockBlack;
6108 0 : sharedLockWhite_ = _sharedLockWhite;
6109 0 : }
6110 :
6111 : } // namespace layers
6112 : } // namespace mozilla
6113 :
6114 : //-----------------------------------------------------------------------------
6115 : // Method definitions for the IPDL type |union MaybeRegion|
6116 : //
6117 : namespace mozilla {
6118 : namespace layers {
6119 0 : auto MaybeRegion::MaybeDestroy(Type aNewType) -> bool
6120 : {
6121 0 : if ((mType) == (T__None)) {
6122 0 : return true;
6123 : }
6124 0 : if ((mType) == (aNewType)) {
6125 0 : return false;
6126 : }
6127 0 : switch (mType) {
6128 : case TnsIntRegion:
6129 : {
6130 0 : (ptr_nsIntRegion())->~nsIntRegion__tdef();
6131 0 : break;
6132 : }
6133 : case Tnull_t:
6134 : {
6135 0 : (ptr_null_t())->~null_t__tdef();
6136 0 : break;
6137 : }
6138 : default:
6139 : {
6140 0 : mozilla::ipc::LogicError("not reached");
6141 0 : break;
6142 : }
6143 : }
6144 0 : return true;
6145 : }
6146 :
6147 0 : MOZ_IMPLICIT MaybeRegion::MaybeRegion(const nsIntRegion& aOther)
6148 : {
6149 0 : new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion(aOther);
6150 0 : mType = TnsIntRegion;
6151 0 : }
6152 :
6153 0 : MOZ_IMPLICIT MaybeRegion::MaybeRegion(const null_t& aOther)
6154 : {
6155 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
6156 0 : mType = Tnull_t;
6157 0 : }
6158 :
6159 0 : MOZ_IMPLICIT MaybeRegion::MaybeRegion(const MaybeRegion& aOther)
6160 : {
6161 0 : (aOther).AssertSanity();
6162 0 : switch ((aOther).type()) {
6163 : case TnsIntRegion:
6164 : {
6165 0 : new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion((aOther).get_nsIntRegion());
6166 0 : break;
6167 : }
6168 : case Tnull_t:
6169 : {
6170 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
6171 0 : break;
6172 : }
6173 : case T__None:
6174 : {
6175 0 : break;
6176 : }
6177 : default:
6178 : {
6179 0 : mozilla::ipc::LogicError("unreached");
6180 0 : return;
6181 : }
6182 : }
6183 0 : mType = (aOther).type();
6184 : }
6185 :
6186 0 : MaybeRegion::~MaybeRegion()
6187 : {
6188 0 : static_cast<void>(MaybeDestroy(T__None));
6189 0 : }
6190 :
6191 0 : auto MaybeRegion::operator=(const nsIntRegion& aRhs) -> MaybeRegion&
6192 : {
6193 0 : if (MaybeDestroy(TnsIntRegion)) {
6194 0 : new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion;
6195 : }
6196 0 : (*(ptr_nsIntRegion())) = aRhs;
6197 0 : mType = TnsIntRegion;
6198 0 : return (*(this));
6199 : }
6200 :
6201 0 : auto MaybeRegion::operator=(const null_t& aRhs) -> MaybeRegion&
6202 : {
6203 0 : if (MaybeDestroy(Tnull_t)) {
6204 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
6205 : }
6206 0 : (*(ptr_null_t())) = aRhs;
6207 0 : mType = Tnull_t;
6208 0 : return (*(this));
6209 : }
6210 :
6211 0 : auto MaybeRegion::operator=(const MaybeRegion& aRhs) -> MaybeRegion&
6212 : {
6213 0 : (aRhs).AssertSanity();
6214 0 : Type t = (aRhs).type();
6215 0 : switch (t) {
6216 : case TnsIntRegion:
6217 : {
6218 0 : if (MaybeDestroy(t)) {
6219 0 : new (mozilla::KnownNotNull, ptr_nsIntRegion()) nsIntRegion;
6220 : }
6221 0 : (*(ptr_nsIntRegion())) = (aRhs).get_nsIntRegion();
6222 0 : break;
6223 : }
6224 : case Tnull_t:
6225 : {
6226 0 : if (MaybeDestroy(t)) {
6227 0 : new (mozilla::KnownNotNull, ptr_null_t()) null_t;
6228 : }
6229 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
6230 0 : break;
6231 : }
6232 : case T__None:
6233 : {
6234 0 : static_cast<void>(MaybeDestroy(t));
6235 0 : break;
6236 : }
6237 : default:
6238 : {
6239 0 : mozilla::ipc::LogicError("unreached");
6240 0 : break;
6241 : }
6242 : }
6243 0 : mType = t;
6244 0 : return (*(this));
6245 : }
6246 :
6247 0 : auto MaybeRegion::operator==(const nsIntRegion& aRhs) const -> bool
6248 : {
6249 0 : return (get_nsIntRegion()) == (aRhs);
6250 : }
6251 :
6252 0 : auto MaybeRegion::operator==(const null_t& aRhs) const -> bool
6253 : {
6254 0 : return (get_null_t()) == (aRhs);
6255 : }
6256 :
6257 0 : auto MaybeRegion::operator==(const MaybeRegion& aRhs) const -> bool
6258 : {
6259 0 : if ((type()) != ((aRhs).type())) {
6260 0 : return false;
6261 : }
6262 :
6263 0 : switch (type()) {
6264 : case TnsIntRegion:
6265 : {
6266 0 : return (get_nsIntRegion()) == ((aRhs).get_nsIntRegion());
6267 : }
6268 : case Tnull_t:
6269 : {
6270 0 : return (get_null_t()) == ((aRhs).get_null_t());
6271 : }
6272 : default:
6273 : {
6274 0 : mozilla::ipc::LogicError("unreached");
6275 0 : return false;
6276 : }
6277 : }
6278 : }
6279 :
6280 0 : auto MaybeRegion::get(nsIntRegion* aOutValue) const -> void
6281 : {
6282 0 : (*(aOutValue)) = get_nsIntRegion();
6283 0 : }
6284 :
6285 0 : auto MaybeRegion::get(null_t* aOutValue) const -> void
6286 : {
6287 0 : (*(aOutValue)) = get_null_t();
6288 0 : }
6289 :
6290 : } // namespace layers
6291 : } // namespace mozilla
6292 :
6293 : //-----------------------------------------------------------------------------
6294 : // Method definitions for the IPDL type |struct OpNotifyNotUsed|
6295 : //
6296 : namespace mozilla {
6297 : namespace layers {
6298 0 : MOZ_IMPLICIT OpNotifyNotUsed::OpNotifyNotUsed() :
6299 : TextureId_(),
6300 0 : fwdTransactionId_()
6301 : {
6302 0 : Init();
6303 0 : }
6304 :
6305 0 : OpNotifyNotUsed::~OpNotifyNotUsed()
6306 : {
6307 0 : }
6308 :
6309 0 : auto OpNotifyNotUsed::operator==(const OpNotifyNotUsed& _o) const -> bool
6310 : {
6311 0 : if ((!((TextureId()) == ((_o).TextureId())))) {
6312 0 : return false;
6313 : }
6314 0 : if ((!((fwdTransactionId()) == ((_o).fwdTransactionId())))) {
6315 0 : return false;
6316 : }
6317 0 : return true;
6318 : }
6319 :
6320 0 : auto OpNotifyNotUsed::operator!=(const OpNotifyNotUsed& _o) const -> bool
6321 : {
6322 0 : return (!(operator==(_o)));
6323 : }
6324 :
6325 0 : auto OpNotifyNotUsed::Init() -> void
6326 : {
6327 0 : }
6328 :
6329 0 : auto OpNotifyNotUsed::Assign(
6330 : const uint64_t& _TextureId,
6331 : const uint64_t& _fwdTransactionId) -> void
6332 : {
6333 0 : TextureId_ = _TextureId;
6334 0 : fwdTransactionId_ = _fwdTransactionId;
6335 0 : }
6336 :
6337 : } // namespace layers
6338 : } // namespace mozilla
6339 :
6340 : //-----------------------------------------------------------------------------
6341 : // Method definitions for the IPDL type |union CompositableOperationDetail|
6342 : //
6343 : namespace mozilla {
6344 : namespace layers {
6345 660 : auto CompositableOperationDetail::MaybeDestroy(Type aNewType) -> bool
6346 : {
6347 660 : if ((mType) == (T__None)) {
6348 330 : return true;
6349 : }
6350 330 : if ((mType) == (aNewType)) {
6351 0 : return false;
6352 : }
6353 330 : switch (mType) {
6354 : case TOpPaintTextureRegion:
6355 : {
6356 165 : (ptr_OpPaintTextureRegion())->~OpPaintTextureRegion__tdef();
6357 165 : break;
6358 : }
6359 : case TOpUseTiledLayerBuffer:
6360 : {
6361 0 : (ptr_OpUseTiledLayerBuffer())->~OpUseTiledLayerBuffer__tdef();
6362 0 : break;
6363 : }
6364 : case TOpRemoveTexture:
6365 : {
6366 0 : (ptr_OpRemoveTexture())->~OpRemoveTexture__tdef();
6367 0 : break;
6368 : }
6369 : case TOpUseTexture:
6370 : {
6371 165 : (ptr_OpUseTexture())->~OpUseTexture__tdef();
6372 165 : break;
6373 : }
6374 : case TOpUseComponentAlphaTextures:
6375 : {
6376 0 : (ptr_OpUseComponentAlphaTextures())->~OpUseComponentAlphaTextures__tdef();
6377 0 : break;
6378 : }
6379 : default:
6380 : {
6381 0 : mozilla::ipc::LogicError("not reached");
6382 0 : break;
6383 : }
6384 : }
6385 330 : return true;
6386 : }
6387 :
6388 33 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpPaintTextureRegion& aOther)
6389 : {
6390 33 : new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion(aOther);
6391 33 : mType = TOpPaintTextureRegion;
6392 33 : }
6393 :
6394 0 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseTiledLayerBuffer& aOther)
6395 : {
6396 0 : new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer(aOther);
6397 0 : mType = TOpUseTiledLayerBuffer;
6398 0 : }
6399 :
6400 0 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpRemoveTexture& aOther)
6401 : {
6402 0 : new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture(aOther);
6403 0 : mType = TOpRemoveTexture;
6404 0 : }
6405 :
6406 33 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseTexture& aOther)
6407 : {
6408 33 : new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture(aOther);
6409 33 : mType = TOpUseTexture;
6410 33 : }
6411 :
6412 0 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const OpUseComponentAlphaTextures& aOther)
6413 : {
6414 0 : new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures(aOther);
6415 0 : mType = TOpUseComponentAlphaTextures;
6416 0 : }
6417 :
6418 0 : MOZ_IMPLICIT CompositableOperationDetail::CompositableOperationDetail(const CompositableOperationDetail& aOther)
6419 : {
6420 0 : (aOther).AssertSanity();
6421 0 : switch ((aOther).type()) {
6422 : case TOpPaintTextureRegion:
6423 : {
6424 0 : new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion((aOther).get_OpPaintTextureRegion());
6425 0 : break;
6426 : }
6427 : case TOpUseTiledLayerBuffer:
6428 : {
6429 0 : new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer((aOther).get_OpUseTiledLayerBuffer());
6430 0 : break;
6431 : }
6432 : case TOpRemoveTexture:
6433 : {
6434 0 : new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture((aOther).get_OpRemoveTexture());
6435 0 : break;
6436 : }
6437 : case TOpUseTexture:
6438 : {
6439 0 : new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture((aOther).get_OpUseTexture());
6440 0 : break;
6441 : }
6442 : case TOpUseComponentAlphaTextures:
6443 : {
6444 0 : new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures((aOther).get_OpUseComponentAlphaTextures());
6445 0 : break;
6446 : }
6447 : case T__None:
6448 : {
6449 0 : break;
6450 : }
6451 : default:
6452 : {
6453 0 : mozilla::ipc::LogicError("unreached");
6454 0 : return;
6455 : }
6456 : }
6457 0 : mType = (aOther).type();
6458 : }
6459 :
6460 726 : CompositableOperationDetail::~CompositableOperationDetail()
6461 : {
6462 363 : static_cast<void>(MaybeDestroy(T__None));
6463 363 : }
6464 :
6465 33 : auto CompositableOperationDetail::operator=(const OpPaintTextureRegion& aRhs) -> CompositableOperationDetail&
6466 : {
6467 33 : if (MaybeDestroy(TOpPaintTextureRegion)) {
6468 33 : new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
6469 : }
6470 33 : (*(ptr_OpPaintTextureRegion())) = aRhs;
6471 33 : mType = TOpPaintTextureRegion;
6472 33 : return (*(this));
6473 : }
6474 :
6475 0 : auto CompositableOperationDetail::operator=(const OpUseTiledLayerBuffer& aRhs) -> CompositableOperationDetail&
6476 : {
6477 0 : if (MaybeDestroy(TOpUseTiledLayerBuffer)) {
6478 0 : new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
6479 : }
6480 0 : (*(ptr_OpUseTiledLayerBuffer())) = aRhs;
6481 0 : mType = TOpUseTiledLayerBuffer;
6482 0 : return (*(this));
6483 : }
6484 :
6485 0 : auto CompositableOperationDetail::operator=(const OpRemoveTexture& aRhs) -> CompositableOperationDetail&
6486 : {
6487 0 : if (MaybeDestroy(TOpRemoveTexture)) {
6488 0 : new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture;
6489 : }
6490 0 : (*(ptr_OpRemoveTexture())) = aRhs;
6491 0 : mType = TOpRemoveTexture;
6492 0 : return (*(this));
6493 : }
6494 :
6495 33 : auto CompositableOperationDetail::operator=(const OpUseTexture& aRhs) -> CompositableOperationDetail&
6496 : {
6497 33 : if (MaybeDestroy(TOpUseTexture)) {
6498 33 : new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture;
6499 : }
6500 33 : (*(ptr_OpUseTexture())) = aRhs;
6501 33 : mType = TOpUseTexture;
6502 33 : return (*(this));
6503 : }
6504 :
6505 0 : auto CompositableOperationDetail::operator=(const OpUseComponentAlphaTextures& aRhs) -> CompositableOperationDetail&
6506 : {
6507 0 : if (MaybeDestroy(TOpUseComponentAlphaTextures)) {
6508 0 : new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
6509 : }
6510 0 : (*(ptr_OpUseComponentAlphaTextures())) = aRhs;
6511 0 : mType = TOpUseComponentAlphaTextures;
6512 0 : return (*(this));
6513 : }
6514 :
6515 231 : auto CompositableOperationDetail::operator=(const CompositableOperationDetail& aRhs) -> CompositableOperationDetail&
6516 : {
6517 231 : (aRhs).AssertSanity();
6518 231 : Type t = (aRhs).type();
6519 231 : switch (t) {
6520 : case TOpPaintTextureRegion:
6521 : {
6522 99 : if (MaybeDestroy(t)) {
6523 99 : new (mozilla::KnownNotNull, ptr_OpPaintTextureRegion()) OpPaintTextureRegion;
6524 : }
6525 99 : (*(ptr_OpPaintTextureRegion())) = (aRhs).get_OpPaintTextureRegion();
6526 99 : break;
6527 : }
6528 : case TOpUseTiledLayerBuffer:
6529 : {
6530 0 : if (MaybeDestroy(t)) {
6531 0 : new (mozilla::KnownNotNull, ptr_OpUseTiledLayerBuffer()) OpUseTiledLayerBuffer;
6532 : }
6533 0 : (*(ptr_OpUseTiledLayerBuffer())) = (aRhs).get_OpUseTiledLayerBuffer();
6534 0 : break;
6535 : }
6536 : case TOpRemoveTexture:
6537 : {
6538 0 : if (MaybeDestroy(t)) {
6539 0 : new (mozilla::KnownNotNull, ptr_OpRemoveTexture()) OpRemoveTexture;
6540 : }
6541 0 : (*(ptr_OpRemoveTexture())) = (aRhs).get_OpRemoveTexture();
6542 0 : break;
6543 : }
6544 : case TOpUseTexture:
6545 : {
6546 99 : if (MaybeDestroy(t)) {
6547 99 : new (mozilla::KnownNotNull, ptr_OpUseTexture()) OpUseTexture;
6548 : }
6549 99 : (*(ptr_OpUseTexture())) = (aRhs).get_OpUseTexture();
6550 99 : break;
6551 : }
6552 : case TOpUseComponentAlphaTextures:
6553 : {
6554 0 : if (MaybeDestroy(t)) {
6555 0 : new (mozilla::KnownNotNull, ptr_OpUseComponentAlphaTextures()) OpUseComponentAlphaTextures;
6556 : }
6557 0 : (*(ptr_OpUseComponentAlphaTextures())) = (aRhs).get_OpUseComponentAlphaTextures();
6558 0 : break;
6559 : }
6560 : case T__None:
6561 : {
6562 33 : static_cast<void>(MaybeDestroy(t));
6563 33 : break;
6564 : }
6565 : default:
6566 : {
6567 0 : mozilla::ipc::LogicError("unreached");
6568 0 : break;
6569 : }
6570 : }
6571 231 : mType = t;
6572 231 : return (*(this));
6573 : }
6574 :
6575 0 : auto CompositableOperationDetail::operator==(const OpPaintTextureRegion& aRhs) const -> bool
6576 : {
6577 0 : return (get_OpPaintTextureRegion()) == (aRhs);
6578 : }
6579 :
6580 0 : auto CompositableOperationDetail::operator==(const OpUseTiledLayerBuffer& aRhs) const -> bool
6581 : {
6582 0 : return (get_OpUseTiledLayerBuffer()) == (aRhs);
6583 : }
6584 :
6585 0 : auto CompositableOperationDetail::operator==(const OpRemoveTexture& aRhs) const -> bool
6586 : {
6587 0 : return (get_OpRemoveTexture()) == (aRhs);
6588 : }
6589 :
6590 0 : auto CompositableOperationDetail::operator==(const OpUseTexture& aRhs) const -> bool
6591 : {
6592 0 : return (get_OpUseTexture()) == (aRhs);
6593 : }
6594 :
6595 0 : auto CompositableOperationDetail::operator==(const OpUseComponentAlphaTextures& aRhs) const -> bool
6596 : {
6597 0 : return (get_OpUseComponentAlphaTextures()) == (aRhs);
6598 : }
6599 :
6600 0 : auto CompositableOperationDetail::operator==(const CompositableOperationDetail& aRhs) const -> bool
6601 : {
6602 0 : if ((type()) != ((aRhs).type())) {
6603 0 : return false;
6604 : }
6605 :
6606 0 : switch (type()) {
6607 : case TOpPaintTextureRegion:
6608 : {
6609 0 : return (get_OpPaintTextureRegion()) == ((aRhs).get_OpPaintTextureRegion());
6610 : }
6611 : case TOpUseTiledLayerBuffer:
6612 : {
6613 0 : return (get_OpUseTiledLayerBuffer()) == ((aRhs).get_OpUseTiledLayerBuffer());
6614 : }
6615 : case TOpRemoveTexture:
6616 : {
6617 0 : return (get_OpRemoveTexture()) == ((aRhs).get_OpRemoveTexture());
6618 : }
6619 : case TOpUseTexture:
6620 : {
6621 0 : return (get_OpUseTexture()) == ((aRhs).get_OpUseTexture());
6622 : }
6623 : case TOpUseComponentAlphaTextures:
6624 : {
6625 0 : return (get_OpUseComponentAlphaTextures()) == ((aRhs).get_OpUseComponentAlphaTextures());
6626 : }
6627 : default:
6628 : {
6629 0 : mozilla::ipc::LogicError("unreached");
6630 0 : return false;
6631 : }
6632 : }
6633 : }
6634 :
6635 0 : auto CompositableOperationDetail::get(OpPaintTextureRegion* aOutValue) const -> void
6636 : {
6637 0 : (*(aOutValue)) = get_OpPaintTextureRegion();
6638 0 : }
6639 :
6640 0 : auto CompositableOperationDetail::get(OpUseTiledLayerBuffer* aOutValue) const -> void
6641 : {
6642 0 : (*(aOutValue)) = get_OpUseTiledLayerBuffer();
6643 0 : }
6644 :
6645 0 : auto CompositableOperationDetail::get(OpRemoveTexture* aOutValue) const -> void
6646 : {
6647 0 : (*(aOutValue)) = get_OpRemoveTexture();
6648 0 : }
6649 :
6650 0 : auto CompositableOperationDetail::get(OpUseTexture* aOutValue) const -> void
6651 : {
6652 0 : (*(aOutValue)) = get_OpUseTexture();
6653 0 : }
6654 :
6655 0 : auto CompositableOperationDetail::get(OpUseComponentAlphaTextures* aOutValue) const -> void
6656 : {
6657 0 : (*(aOutValue)) = get_OpUseComponentAlphaTextures();
6658 0 : }
6659 :
6660 : } // namespace layers
6661 : } // namespace mozilla
6662 :
6663 : //-----------------------------------------------------------------------------
6664 : // Method definitions for the IPDL type |struct CompositableOperation|
6665 : //
6666 : namespace mozilla {
6667 : namespace layers {
6668 99 : MOZ_IMPLICIT CompositableOperation::CompositableOperation() :
6669 99 : compositable_()
6670 : {
6671 99 : Init();
6672 99 : }
6673 :
6674 297 : CompositableOperation::~CompositableOperation()
6675 : {
6676 297 : }
6677 :
6678 0 : auto CompositableOperation::operator==(const CompositableOperation& _o) const -> bool
6679 : {
6680 0 : if ((!((compositable()) == ((_o).compositable())))) {
6681 0 : return false;
6682 : }
6683 0 : if ((!((detail()) == ((_o).detail())))) {
6684 0 : return false;
6685 : }
6686 0 : return true;
6687 : }
6688 :
6689 0 : auto CompositableOperation::operator!=(const CompositableOperation& _o) const -> bool
6690 : {
6691 0 : return (!(operator==(_o)));
6692 : }
6693 :
6694 297 : auto CompositableOperation::Init() -> void
6695 : {
6696 297 : }
6697 :
6698 231 : auto CompositableOperation::Assign(
6699 : const CompositableHandle& _compositable,
6700 : const CompositableOperationDetail& _detail) -> void
6701 : {
6702 231 : compositable_ = _compositable;
6703 231 : detail_ = _detail;
6704 231 : }
6705 :
6706 : } // namespace layers
6707 : } // namespace mozilla
6708 :
6709 : //-----------------------------------------------------------------------------
6710 : // Method definitions for the IPDL type |union Edit|
6711 : //
6712 : namespace mozilla {
6713 : namespace layers {
6714 581 : auto Edit::MaybeDestroy(Type aNewType) -> bool
6715 : {
6716 581 : if ((mType) == (T__None)) {
6717 137 : return true;
6718 : }
6719 444 : if ((mType) == (aNewType)) {
6720 0 : return false;
6721 : }
6722 444 : switch (mType) {
6723 : case TOpCreatePaintedLayer:
6724 : {
6725 66 : (ptr_OpCreatePaintedLayer())->~OpCreatePaintedLayer__tdef();
6726 66 : break;
6727 : }
6728 : case TOpCreateContainerLayer:
6729 : {
6730 12 : (ptr_OpCreateContainerLayer())->~OpCreateContainerLayer__tdef();
6731 12 : break;
6732 : }
6733 : case TOpCreateImageLayer:
6734 : {
6735 0 : (ptr_OpCreateImageLayer())->~OpCreateImageLayer__tdef();
6736 0 : break;
6737 : }
6738 : case TOpCreateColorLayer:
6739 : {
6740 12 : (ptr_OpCreateColorLayer())->~OpCreateColorLayer__tdef();
6741 12 : break;
6742 : }
6743 : case TOpCreateTextLayer:
6744 : {
6745 0 : (ptr_OpCreateTextLayer())->~OpCreateTextLayer__tdef();
6746 0 : break;
6747 : }
6748 : case TOpCreateBorderLayer:
6749 : {
6750 0 : (ptr_OpCreateBorderLayer())->~OpCreateBorderLayer__tdef();
6751 0 : break;
6752 : }
6753 : case TOpCreateCanvasLayer:
6754 : {
6755 0 : (ptr_OpCreateCanvasLayer())->~OpCreateCanvasLayer__tdef();
6756 0 : break;
6757 : }
6758 : case TOpCreateRefLayer:
6759 : {
6760 3 : (ptr_OpCreateRefLayer())->~OpCreateRefLayer__tdef();
6761 3 : break;
6762 : }
6763 : case TOpSetDiagnosticTypes:
6764 : {
6765 0 : (ptr_OpSetDiagnosticTypes())->~OpSetDiagnosticTypes__tdef();
6766 0 : break;
6767 : }
6768 : case TOpWindowOverlayChanged:
6769 : {
6770 0 : (ptr_OpWindowOverlayChanged())->~OpWindowOverlayChanged__tdef();
6771 0 : break;
6772 : }
6773 : case TOpSetRoot:
6774 : {
6775 12 : (ptr_OpSetRoot())->~OpSetRoot__tdef();
6776 12 : break;
6777 : }
6778 : case TOpInsertAfter:
6779 : {
6780 69 : (ptr_OpInsertAfter())->~OpInsertAfter__tdef();
6781 69 : break;
6782 : }
6783 : case TOpPrependChild:
6784 : {
6785 12 : (ptr_OpPrependChild())->~OpPrependChild__tdef();
6786 12 : break;
6787 : }
6788 : case TOpRemoveChild:
6789 : {
6790 60 : (ptr_OpRemoveChild())->~OpRemoveChild__tdef();
6791 60 : break;
6792 : }
6793 : case TOpRepositionChild:
6794 : {
6795 0 : (ptr_OpRepositionChild())->~OpRepositionChild__tdef();
6796 0 : break;
6797 : }
6798 : case TOpRaiseToTopChild:
6799 : {
6800 0 : (ptr_OpRaiseToTopChild())->~OpRaiseToTopChild__tdef();
6801 0 : break;
6802 : }
6803 : case TOpAttachCompositable:
6804 : {
6805 66 : (ptr_OpAttachCompositable())->~OpAttachCompositable__tdef();
6806 66 : break;
6807 : }
6808 : case TOpAttachAsyncCompositable:
6809 : {
6810 0 : (ptr_OpAttachAsyncCompositable())->~OpAttachAsyncCompositable__tdef();
6811 0 : break;
6812 : }
6813 : case TCompositableOperation:
6814 : {
6815 132 : (ptr_CompositableOperation())->~CompositableOperation__tdef();
6816 132 : break;
6817 : }
6818 : default:
6819 : {
6820 0 : mozilla::ipc::LogicError("not reached");
6821 0 : break;
6822 : }
6823 : }
6824 444 : return true;
6825 : }
6826 :
6827 22 : MOZ_IMPLICIT Edit::Edit(const OpCreatePaintedLayer& aOther)
6828 : {
6829 22 : new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer(aOther);
6830 22 : mType = TOpCreatePaintedLayer;
6831 22 : }
6832 :
6833 4 : MOZ_IMPLICIT Edit::Edit(const OpCreateContainerLayer& aOther)
6834 : {
6835 4 : new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer(aOther);
6836 4 : mType = TOpCreateContainerLayer;
6837 4 : }
6838 :
6839 0 : MOZ_IMPLICIT Edit::Edit(const OpCreateImageLayer& aOther)
6840 : {
6841 0 : new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer(aOther);
6842 0 : mType = TOpCreateImageLayer;
6843 0 : }
6844 :
6845 4 : MOZ_IMPLICIT Edit::Edit(const OpCreateColorLayer& aOther)
6846 : {
6847 4 : new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer(aOther);
6848 4 : mType = TOpCreateColorLayer;
6849 4 : }
6850 :
6851 0 : MOZ_IMPLICIT Edit::Edit(const OpCreateTextLayer& aOther)
6852 : {
6853 0 : new (mozilla::KnownNotNull, ptr_OpCreateTextLayer()) OpCreateTextLayer(aOther);
6854 0 : mType = TOpCreateTextLayer;
6855 0 : }
6856 :
6857 0 : MOZ_IMPLICIT Edit::Edit(const OpCreateBorderLayer& aOther)
6858 : {
6859 0 : new (mozilla::KnownNotNull, ptr_OpCreateBorderLayer()) OpCreateBorderLayer(aOther);
6860 0 : mType = TOpCreateBorderLayer;
6861 0 : }
6862 :
6863 0 : MOZ_IMPLICIT Edit::Edit(const OpCreateCanvasLayer& aOther)
6864 : {
6865 0 : new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer(aOther);
6866 0 : mType = TOpCreateCanvasLayer;
6867 0 : }
6868 :
6869 1 : MOZ_IMPLICIT Edit::Edit(const OpCreateRefLayer& aOther)
6870 : {
6871 1 : new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer(aOther);
6872 1 : mType = TOpCreateRefLayer;
6873 1 : }
6874 :
6875 0 : MOZ_IMPLICIT Edit::Edit(const OpSetDiagnosticTypes& aOther)
6876 : {
6877 0 : new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes(aOther);
6878 0 : mType = TOpSetDiagnosticTypes;
6879 0 : }
6880 :
6881 0 : MOZ_IMPLICIT Edit::Edit(const OpWindowOverlayChanged& aOther)
6882 : {
6883 0 : new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged(aOther);
6884 0 : mType = TOpWindowOverlayChanged;
6885 0 : }
6886 :
6887 4 : MOZ_IMPLICIT Edit::Edit(const OpSetRoot& aOther)
6888 : {
6889 4 : new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot(aOther);
6890 4 : mType = TOpSetRoot;
6891 4 : }
6892 :
6893 23 : MOZ_IMPLICIT Edit::Edit(const OpInsertAfter& aOther)
6894 : {
6895 23 : new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter(aOther);
6896 23 : mType = TOpInsertAfter;
6897 23 : }
6898 :
6899 4 : MOZ_IMPLICIT Edit::Edit(const OpPrependChild& aOther)
6900 : {
6901 4 : new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild(aOther);
6902 4 : mType = TOpPrependChild;
6903 4 : }
6904 :
6905 20 : MOZ_IMPLICIT Edit::Edit(const OpRemoveChild& aOther)
6906 : {
6907 20 : new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild(aOther);
6908 20 : mType = TOpRemoveChild;
6909 20 : }
6910 :
6911 0 : MOZ_IMPLICIT Edit::Edit(const OpRepositionChild& aOther)
6912 : {
6913 0 : new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild(aOther);
6914 0 : mType = TOpRepositionChild;
6915 0 : }
6916 :
6917 0 : MOZ_IMPLICIT Edit::Edit(const OpRaiseToTopChild& aOther)
6918 : {
6919 0 : new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild(aOther);
6920 0 : mType = TOpRaiseToTopChild;
6921 0 : }
6922 :
6923 22 : MOZ_IMPLICIT Edit::Edit(const OpAttachCompositable& aOther)
6924 : {
6925 22 : new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable(aOther);
6926 22 : mType = TOpAttachCompositable;
6927 22 : }
6928 :
6929 0 : MOZ_IMPLICIT Edit::Edit(const OpAttachAsyncCompositable& aOther)
6930 : {
6931 0 : new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable(aOther);
6932 0 : mType = TOpAttachAsyncCompositable;
6933 0 : }
6934 :
6935 66 : MOZ_IMPLICIT Edit::Edit(const CompositableOperation& aOther)
6936 : {
6937 66 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation(aOther);
6938 66 : mType = TCompositableOperation;
6939 66 : }
6940 :
6941 137 : MOZ_IMPLICIT Edit::Edit(const Edit& aOther)
6942 : {
6943 137 : (aOther).AssertSanity();
6944 137 : switch ((aOther).type()) {
6945 : case TOpCreatePaintedLayer:
6946 : {
6947 22 : new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer((aOther).get_OpCreatePaintedLayer());
6948 22 : break;
6949 : }
6950 : case TOpCreateContainerLayer:
6951 : {
6952 4 : new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer((aOther).get_OpCreateContainerLayer());
6953 4 : break;
6954 : }
6955 : case TOpCreateImageLayer:
6956 : {
6957 0 : new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer((aOther).get_OpCreateImageLayer());
6958 0 : break;
6959 : }
6960 : case TOpCreateColorLayer:
6961 : {
6962 4 : new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer((aOther).get_OpCreateColorLayer());
6963 4 : break;
6964 : }
6965 : case TOpCreateTextLayer:
6966 : {
6967 0 : new (mozilla::KnownNotNull, ptr_OpCreateTextLayer()) OpCreateTextLayer((aOther).get_OpCreateTextLayer());
6968 0 : break;
6969 : }
6970 : case TOpCreateBorderLayer:
6971 : {
6972 0 : new (mozilla::KnownNotNull, ptr_OpCreateBorderLayer()) OpCreateBorderLayer((aOther).get_OpCreateBorderLayer());
6973 0 : break;
6974 : }
6975 : case TOpCreateCanvasLayer:
6976 : {
6977 0 : new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer((aOther).get_OpCreateCanvasLayer());
6978 0 : break;
6979 : }
6980 : case TOpCreateRefLayer:
6981 : {
6982 1 : new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer((aOther).get_OpCreateRefLayer());
6983 1 : break;
6984 : }
6985 : case TOpSetDiagnosticTypes:
6986 : {
6987 0 : new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes((aOther).get_OpSetDiagnosticTypes());
6988 0 : break;
6989 : }
6990 : case TOpWindowOverlayChanged:
6991 : {
6992 0 : new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged((aOther).get_OpWindowOverlayChanged());
6993 0 : break;
6994 : }
6995 : case TOpSetRoot:
6996 : {
6997 4 : new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot((aOther).get_OpSetRoot());
6998 4 : break;
6999 : }
7000 : case TOpInsertAfter:
7001 : {
7002 23 : new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter((aOther).get_OpInsertAfter());
7003 23 : break;
7004 : }
7005 : case TOpPrependChild:
7006 : {
7007 4 : new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild((aOther).get_OpPrependChild());
7008 4 : break;
7009 : }
7010 : case TOpRemoveChild:
7011 : {
7012 20 : new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild((aOther).get_OpRemoveChild());
7013 20 : break;
7014 : }
7015 : case TOpRepositionChild:
7016 : {
7017 0 : new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild((aOther).get_OpRepositionChild());
7018 0 : break;
7019 : }
7020 : case TOpRaiseToTopChild:
7021 : {
7022 0 : new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild((aOther).get_OpRaiseToTopChild());
7023 0 : break;
7024 : }
7025 : case TOpAttachCompositable:
7026 : {
7027 22 : new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable((aOther).get_OpAttachCompositable());
7028 22 : break;
7029 : }
7030 : case TOpAttachAsyncCompositable:
7031 : {
7032 0 : new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable((aOther).get_OpAttachAsyncCompositable());
7033 0 : break;
7034 : }
7035 : case TCompositableOperation:
7036 : {
7037 33 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation((aOther).get_CompositableOperation());
7038 33 : break;
7039 : }
7040 : case T__None:
7041 : {
7042 0 : break;
7043 : }
7044 : default:
7045 : {
7046 0 : mozilla::ipc::LogicError("unreached");
7047 0 : return;
7048 : }
7049 : }
7050 137 : mType = (aOther).type();
7051 : }
7052 :
7053 888 : Edit::~Edit()
7054 : {
7055 444 : static_cast<void>(MaybeDestroy(T__None));
7056 444 : }
7057 :
7058 22 : auto Edit::operator=(const OpCreatePaintedLayer& aRhs) -> Edit&
7059 : {
7060 22 : if (MaybeDestroy(TOpCreatePaintedLayer)) {
7061 22 : new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
7062 : }
7063 22 : (*(ptr_OpCreatePaintedLayer())) = aRhs;
7064 22 : mType = TOpCreatePaintedLayer;
7065 22 : return (*(this));
7066 : }
7067 :
7068 4 : auto Edit::operator=(const OpCreateContainerLayer& aRhs) -> Edit&
7069 : {
7070 4 : if (MaybeDestroy(TOpCreateContainerLayer)) {
7071 4 : new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
7072 : }
7073 4 : (*(ptr_OpCreateContainerLayer())) = aRhs;
7074 4 : mType = TOpCreateContainerLayer;
7075 4 : return (*(this));
7076 : }
7077 :
7078 0 : auto Edit::operator=(const OpCreateImageLayer& aRhs) -> Edit&
7079 : {
7080 0 : if (MaybeDestroy(TOpCreateImageLayer)) {
7081 0 : new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
7082 : }
7083 0 : (*(ptr_OpCreateImageLayer())) = aRhs;
7084 0 : mType = TOpCreateImageLayer;
7085 0 : return (*(this));
7086 : }
7087 :
7088 4 : auto Edit::operator=(const OpCreateColorLayer& aRhs) -> Edit&
7089 : {
7090 4 : if (MaybeDestroy(TOpCreateColorLayer)) {
7091 4 : new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
7092 : }
7093 4 : (*(ptr_OpCreateColorLayer())) = aRhs;
7094 4 : mType = TOpCreateColorLayer;
7095 4 : return (*(this));
7096 : }
7097 :
7098 0 : auto Edit::operator=(const OpCreateTextLayer& aRhs) -> Edit&
7099 : {
7100 0 : if (MaybeDestroy(TOpCreateTextLayer)) {
7101 0 : new (mozilla::KnownNotNull, ptr_OpCreateTextLayer()) OpCreateTextLayer;
7102 : }
7103 0 : (*(ptr_OpCreateTextLayer())) = aRhs;
7104 0 : mType = TOpCreateTextLayer;
7105 0 : return (*(this));
7106 : }
7107 :
7108 0 : auto Edit::operator=(const OpCreateBorderLayer& aRhs) -> Edit&
7109 : {
7110 0 : if (MaybeDestroy(TOpCreateBorderLayer)) {
7111 0 : new (mozilla::KnownNotNull, ptr_OpCreateBorderLayer()) OpCreateBorderLayer;
7112 : }
7113 0 : (*(ptr_OpCreateBorderLayer())) = aRhs;
7114 0 : mType = TOpCreateBorderLayer;
7115 0 : return (*(this));
7116 : }
7117 :
7118 0 : auto Edit::operator=(const OpCreateCanvasLayer& aRhs) -> Edit&
7119 : {
7120 0 : if (MaybeDestroy(TOpCreateCanvasLayer)) {
7121 0 : new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
7122 : }
7123 0 : (*(ptr_OpCreateCanvasLayer())) = aRhs;
7124 0 : mType = TOpCreateCanvasLayer;
7125 0 : return (*(this));
7126 : }
7127 :
7128 1 : auto Edit::operator=(const OpCreateRefLayer& aRhs) -> Edit&
7129 : {
7130 1 : if (MaybeDestroy(TOpCreateRefLayer)) {
7131 1 : new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
7132 : }
7133 1 : (*(ptr_OpCreateRefLayer())) = aRhs;
7134 1 : mType = TOpCreateRefLayer;
7135 1 : return (*(this));
7136 : }
7137 :
7138 0 : auto Edit::operator=(const OpSetDiagnosticTypes& aRhs) -> Edit&
7139 : {
7140 0 : if (MaybeDestroy(TOpSetDiagnosticTypes)) {
7141 0 : new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
7142 : }
7143 0 : (*(ptr_OpSetDiagnosticTypes())) = aRhs;
7144 0 : mType = TOpSetDiagnosticTypes;
7145 0 : return (*(this));
7146 : }
7147 :
7148 0 : auto Edit::operator=(const OpWindowOverlayChanged& aRhs) -> Edit&
7149 : {
7150 0 : if (MaybeDestroy(TOpWindowOverlayChanged)) {
7151 0 : new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
7152 : }
7153 0 : (*(ptr_OpWindowOverlayChanged())) = aRhs;
7154 0 : mType = TOpWindowOverlayChanged;
7155 0 : return (*(this));
7156 : }
7157 :
7158 4 : auto Edit::operator=(const OpSetRoot& aRhs) -> Edit&
7159 : {
7160 4 : if (MaybeDestroy(TOpSetRoot)) {
7161 4 : new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
7162 : }
7163 4 : (*(ptr_OpSetRoot())) = aRhs;
7164 4 : mType = TOpSetRoot;
7165 4 : return (*(this));
7166 : }
7167 :
7168 23 : auto Edit::operator=(const OpInsertAfter& aRhs) -> Edit&
7169 : {
7170 23 : if (MaybeDestroy(TOpInsertAfter)) {
7171 23 : new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
7172 : }
7173 23 : (*(ptr_OpInsertAfter())) = aRhs;
7174 23 : mType = TOpInsertAfter;
7175 23 : return (*(this));
7176 : }
7177 :
7178 4 : auto Edit::operator=(const OpPrependChild& aRhs) -> Edit&
7179 : {
7180 4 : if (MaybeDestroy(TOpPrependChild)) {
7181 4 : new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
7182 : }
7183 4 : (*(ptr_OpPrependChild())) = aRhs;
7184 4 : mType = TOpPrependChild;
7185 4 : return (*(this));
7186 : }
7187 :
7188 20 : auto Edit::operator=(const OpRemoveChild& aRhs) -> Edit&
7189 : {
7190 20 : if (MaybeDestroy(TOpRemoveChild)) {
7191 20 : new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
7192 : }
7193 20 : (*(ptr_OpRemoveChild())) = aRhs;
7194 20 : mType = TOpRemoveChild;
7195 20 : return (*(this));
7196 : }
7197 :
7198 0 : auto Edit::operator=(const OpRepositionChild& aRhs) -> Edit&
7199 : {
7200 0 : if (MaybeDestroy(TOpRepositionChild)) {
7201 0 : new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
7202 : }
7203 0 : (*(ptr_OpRepositionChild())) = aRhs;
7204 0 : mType = TOpRepositionChild;
7205 0 : return (*(this));
7206 : }
7207 :
7208 0 : auto Edit::operator=(const OpRaiseToTopChild& aRhs) -> Edit&
7209 : {
7210 0 : if (MaybeDestroy(TOpRaiseToTopChild)) {
7211 0 : new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
7212 : }
7213 0 : (*(ptr_OpRaiseToTopChild())) = aRhs;
7214 0 : mType = TOpRaiseToTopChild;
7215 0 : return (*(this));
7216 : }
7217 :
7218 22 : auto Edit::operator=(const OpAttachCompositable& aRhs) -> Edit&
7219 : {
7220 22 : if (MaybeDestroy(TOpAttachCompositable)) {
7221 22 : new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
7222 : }
7223 22 : (*(ptr_OpAttachCompositable())) = aRhs;
7224 22 : mType = TOpAttachCompositable;
7225 22 : return (*(this));
7226 : }
7227 :
7228 0 : auto Edit::operator=(const OpAttachAsyncCompositable& aRhs) -> Edit&
7229 : {
7230 0 : if (MaybeDestroy(TOpAttachAsyncCompositable)) {
7231 0 : new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
7232 : }
7233 0 : (*(ptr_OpAttachAsyncCompositable())) = aRhs;
7234 0 : mType = TOpAttachAsyncCompositable;
7235 0 : return (*(this));
7236 : }
7237 :
7238 33 : auto Edit::operator=(const CompositableOperation& aRhs) -> Edit&
7239 : {
7240 33 : if (MaybeDestroy(TCompositableOperation)) {
7241 33 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
7242 : }
7243 33 : (*(ptr_CompositableOperation())) = aRhs;
7244 33 : mType = TCompositableOperation;
7245 33 : return (*(this));
7246 : }
7247 :
7248 0 : auto Edit::operator=(const Edit& aRhs) -> Edit&
7249 : {
7250 0 : (aRhs).AssertSanity();
7251 0 : Type t = (aRhs).type();
7252 0 : switch (t) {
7253 : case TOpCreatePaintedLayer:
7254 : {
7255 0 : if (MaybeDestroy(t)) {
7256 0 : new (mozilla::KnownNotNull, ptr_OpCreatePaintedLayer()) OpCreatePaintedLayer;
7257 : }
7258 0 : (*(ptr_OpCreatePaintedLayer())) = (aRhs).get_OpCreatePaintedLayer();
7259 0 : break;
7260 : }
7261 : case TOpCreateContainerLayer:
7262 : {
7263 0 : if (MaybeDestroy(t)) {
7264 0 : new (mozilla::KnownNotNull, ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
7265 : }
7266 0 : (*(ptr_OpCreateContainerLayer())) = (aRhs).get_OpCreateContainerLayer();
7267 0 : break;
7268 : }
7269 : case TOpCreateImageLayer:
7270 : {
7271 0 : if (MaybeDestroy(t)) {
7272 0 : new (mozilla::KnownNotNull, ptr_OpCreateImageLayer()) OpCreateImageLayer;
7273 : }
7274 0 : (*(ptr_OpCreateImageLayer())) = (aRhs).get_OpCreateImageLayer();
7275 0 : break;
7276 : }
7277 : case TOpCreateColorLayer:
7278 : {
7279 0 : if (MaybeDestroy(t)) {
7280 0 : new (mozilla::KnownNotNull, ptr_OpCreateColorLayer()) OpCreateColorLayer;
7281 : }
7282 0 : (*(ptr_OpCreateColorLayer())) = (aRhs).get_OpCreateColorLayer();
7283 0 : break;
7284 : }
7285 : case TOpCreateTextLayer:
7286 : {
7287 0 : if (MaybeDestroy(t)) {
7288 0 : new (mozilla::KnownNotNull, ptr_OpCreateTextLayer()) OpCreateTextLayer;
7289 : }
7290 0 : (*(ptr_OpCreateTextLayer())) = (aRhs).get_OpCreateTextLayer();
7291 0 : break;
7292 : }
7293 : case TOpCreateBorderLayer:
7294 : {
7295 0 : if (MaybeDestroy(t)) {
7296 0 : new (mozilla::KnownNotNull, ptr_OpCreateBorderLayer()) OpCreateBorderLayer;
7297 : }
7298 0 : (*(ptr_OpCreateBorderLayer())) = (aRhs).get_OpCreateBorderLayer();
7299 0 : break;
7300 : }
7301 : case TOpCreateCanvasLayer:
7302 : {
7303 0 : if (MaybeDestroy(t)) {
7304 0 : new (mozilla::KnownNotNull, ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
7305 : }
7306 0 : (*(ptr_OpCreateCanvasLayer())) = (aRhs).get_OpCreateCanvasLayer();
7307 0 : break;
7308 : }
7309 : case TOpCreateRefLayer:
7310 : {
7311 0 : if (MaybeDestroy(t)) {
7312 0 : new (mozilla::KnownNotNull, ptr_OpCreateRefLayer()) OpCreateRefLayer;
7313 : }
7314 0 : (*(ptr_OpCreateRefLayer())) = (aRhs).get_OpCreateRefLayer();
7315 0 : break;
7316 : }
7317 : case TOpSetDiagnosticTypes:
7318 : {
7319 0 : if (MaybeDestroy(t)) {
7320 0 : new (mozilla::KnownNotNull, ptr_OpSetDiagnosticTypes()) OpSetDiagnosticTypes;
7321 : }
7322 0 : (*(ptr_OpSetDiagnosticTypes())) = (aRhs).get_OpSetDiagnosticTypes();
7323 0 : break;
7324 : }
7325 : case TOpWindowOverlayChanged:
7326 : {
7327 0 : if (MaybeDestroy(t)) {
7328 0 : new (mozilla::KnownNotNull, ptr_OpWindowOverlayChanged()) OpWindowOverlayChanged;
7329 : }
7330 0 : (*(ptr_OpWindowOverlayChanged())) = (aRhs).get_OpWindowOverlayChanged();
7331 0 : break;
7332 : }
7333 : case TOpSetRoot:
7334 : {
7335 0 : if (MaybeDestroy(t)) {
7336 0 : new (mozilla::KnownNotNull, ptr_OpSetRoot()) OpSetRoot;
7337 : }
7338 0 : (*(ptr_OpSetRoot())) = (aRhs).get_OpSetRoot();
7339 0 : break;
7340 : }
7341 : case TOpInsertAfter:
7342 : {
7343 0 : if (MaybeDestroy(t)) {
7344 0 : new (mozilla::KnownNotNull, ptr_OpInsertAfter()) OpInsertAfter;
7345 : }
7346 0 : (*(ptr_OpInsertAfter())) = (aRhs).get_OpInsertAfter();
7347 0 : break;
7348 : }
7349 : case TOpPrependChild:
7350 : {
7351 0 : if (MaybeDestroy(t)) {
7352 0 : new (mozilla::KnownNotNull, ptr_OpPrependChild()) OpPrependChild;
7353 : }
7354 0 : (*(ptr_OpPrependChild())) = (aRhs).get_OpPrependChild();
7355 0 : break;
7356 : }
7357 : case TOpRemoveChild:
7358 : {
7359 0 : if (MaybeDestroy(t)) {
7360 0 : new (mozilla::KnownNotNull, ptr_OpRemoveChild()) OpRemoveChild;
7361 : }
7362 0 : (*(ptr_OpRemoveChild())) = (aRhs).get_OpRemoveChild();
7363 0 : break;
7364 : }
7365 : case TOpRepositionChild:
7366 : {
7367 0 : if (MaybeDestroy(t)) {
7368 0 : new (mozilla::KnownNotNull, ptr_OpRepositionChild()) OpRepositionChild;
7369 : }
7370 0 : (*(ptr_OpRepositionChild())) = (aRhs).get_OpRepositionChild();
7371 0 : break;
7372 : }
7373 : case TOpRaiseToTopChild:
7374 : {
7375 0 : if (MaybeDestroy(t)) {
7376 0 : new (mozilla::KnownNotNull, ptr_OpRaiseToTopChild()) OpRaiseToTopChild;
7377 : }
7378 0 : (*(ptr_OpRaiseToTopChild())) = (aRhs).get_OpRaiseToTopChild();
7379 0 : break;
7380 : }
7381 : case TOpAttachCompositable:
7382 : {
7383 0 : if (MaybeDestroy(t)) {
7384 0 : new (mozilla::KnownNotNull, ptr_OpAttachCompositable()) OpAttachCompositable;
7385 : }
7386 0 : (*(ptr_OpAttachCompositable())) = (aRhs).get_OpAttachCompositable();
7387 0 : break;
7388 : }
7389 : case TOpAttachAsyncCompositable:
7390 : {
7391 0 : if (MaybeDestroy(t)) {
7392 0 : new (mozilla::KnownNotNull, ptr_OpAttachAsyncCompositable()) OpAttachAsyncCompositable;
7393 : }
7394 0 : (*(ptr_OpAttachAsyncCompositable())) = (aRhs).get_OpAttachAsyncCompositable();
7395 0 : break;
7396 : }
7397 : case TCompositableOperation:
7398 : {
7399 0 : if (MaybeDestroy(t)) {
7400 0 : new (mozilla::KnownNotNull, ptr_CompositableOperation()) CompositableOperation;
7401 : }
7402 0 : (*(ptr_CompositableOperation())) = (aRhs).get_CompositableOperation();
7403 0 : break;
7404 : }
7405 : case T__None:
7406 : {
7407 0 : static_cast<void>(MaybeDestroy(t));
7408 0 : break;
7409 : }
7410 : default:
7411 : {
7412 0 : mozilla::ipc::LogicError("unreached");
7413 0 : break;
7414 : }
7415 : }
7416 0 : mType = t;
7417 0 : return (*(this));
7418 : }
7419 :
7420 0 : auto Edit::operator==(const OpCreatePaintedLayer& aRhs) const -> bool
7421 : {
7422 0 : return (get_OpCreatePaintedLayer()) == (aRhs);
7423 : }
7424 :
7425 0 : auto Edit::operator==(const OpCreateContainerLayer& aRhs) const -> bool
7426 : {
7427 0 : return (get_OpCreateContainerLayer()) == (aRhs);
7428 : }
7429 :
7430 0 : auto Edit::operator==(const OpCreateImageLayer& aRhs) const -> bool
7431 : {
7432 0 : return (get_OpCreateImageLayer()) == (aRhs);
7433 : }
7434 :
7435 0 : auto Edit::operator==(const OpCreateColorLayer& aRhs) const -> bool
7436 : {
7437 0 : return (get_OpCreateColorLayer()) == (aRhs);
7438 : }
7439 :
7440 0 : auto Edit::operator==(const OpCreateTextLayer& aRhs) const -> bool
7441 : {
7442 0 : return (get_OpCreateTextLayer()) == (aRhs);
7443 : }
7444 :
7445 0 : auto Edit::operator==(const OpCreateBorderLayer& aRhs) const -> bool
7446 : {
7447 0 : return (get_OpCreateBorderLayer()) == (aRhs);
7448 : }
7449 :
7450 0 : auto Edit::operator==(const OpCreateCanvasLayer& aRhs) const -> bool
7451 : {
7452 0 : return (get_OpCreateCanvasLayer()) == (aRhs);
7453 : }
7454 :
7455 0 : auto Edit::operator==(const OpCreateRefLayer& aRhs) const -> bool
7456 : {
7457 0 : return (get_OpCreateRefLayer()) == (aRhs);
7458 : }
7459 :
7460 0 : auto Edit::operator==(const OpSetDiagnosticTypes& aRhs) const -> bool
7461 : {
7462 0 : return (get_OpSetDiagnosticTypes()) == (aRhs);
7463 : }
7464 :
7465 0 : auto Edit::operator==(const OpWindowOverlayChanged& aRhs) const -> bool
7466 : {
7467 0 : return (get_OpWindowOverlayChanged()) == (aRhs);
7468 : }
7469 :
7470 0 : auto Edit::operator==(const OpSetRoot& aRhs) const -> bool
7471 : {
7472 0 : return (get_OpSetRoot()) == (aRhs);
7473 : }
7474 :
7475 0 : auto Edit::operator==(const OpInsertAfter& aRhs) const -> bool
7476 : {
7477 0 : return (get_OpInsertAfter()) == (aRhs);
7478 : }
7479 :
7480 0 : auto Edit::operator==(const OpPrependChild& aRhs) const -> bool
7481 : {
7482 0 : return (get_OpPrependChild()) == (aRhs);
7483 : }
7484 :
7485 0 : auto Edit::operator==(const OpRemoveChild& aRhs) const -> bool
7486 : {
7487 0 : return (get_OpRemoveChild()) == (aRhs);
7488 : }
7489 :
7490 0 : auto Edit::operator==(const OpRepositionChild& aRhs) const -> bool
7491 : {
7492 0 : return (get_OpRepositionChild()) == (aRhs);
7493 : }
7494 :
7495 0 : auto Edit::operator==(const OpRaiseToTopChild& aRhs) const -> bool
7496 : {
7497 0 : return (get_OpRaiseToTopChild()) == (aRhs);
7498 : }
7499 :
7500 0 : auto Edit::operator==(const OpAttachCompositable& aRhs) const -> bool
7501 : {
7502 0 : return (get_OpAttachCompositable()) == (aRhs);
7503 : }
7504 :
7505 0 : auto Edit::operator==(const OpAttachAsyncCompositable& aRhs) const -> bool
7506 : {
7507 0 : return (get_OpAttachAsyncCompositable()) == (aRhs);
7508 : }
7509 :
7510 0 : auto Edit::operator==(const CompositableOperation& aRhs) const -> bool
7511 : {
7512 0 : return (get_CompositableOperation()) == (aRhs);
7513 : }
7514 :
7515 0 : auto Edit::operator==(const Edit& aRhs) const -> bool
7516 : {
7517 0 : if ((type()) != ((aRhs).type())) {
7518 0 : return false;
7519 : }
7520 :
7521 0 : switch (type()) {
7522 : case TOpCreatePaintedLayer:
7523 : {
7524 0 : return (get_OpCreatePaintedLayer()) == ((aRhs).get_OpCreatePaintedLayer());
7525 : }
7526 : case TOpCreateContainerLayer:
7527 : {
7528 0 : return (get_OpCreateContainerLayer()) == ((aRhs).get_OpCreateContainerLayer());
7529 : }
7530 : case TOpCreateImageLayer:
7531 : {
7532 0 : return (get_OpCreateImageLayer()) == ((aRhs).get_OpCreateImageLayer());
7533 : }
7534 : case TOpCreateColorLayer:
7535 : {
7536 0 : return (get_OpCreateColorLayer()) == ((aRhs).get_OpCreateColorLayer());
7537 : }
7538 : case TOpCreateTextLayer:
7539 : {
7540 0 : return (get_OpCreateTextLayer()) == ((aRhs).get_OpCreateTextLayer());
7541 : }
7542 : case TOpCreateBorderLayer:
7543 : {
7544 0 : return (get_OpCreateBorderLayer()) == ((aRhs).get_OpCreateBorderLayer());
7545 : }
7546 : case TOpCreateCanvasLayer:
7547 : {
7548 0 : return (get_OpCreateCanvasLayer()) == ((aRhs).get_OpCreateCanvasLayer());
7549 : }
7550 : case TOpCreateRefLayer:
7551 : {
7552 0 : return (get_OpCreateRefLayer()) == ((aRhs).get_OpCreateRefLayer());
7553 : }
7554 : case TOpSetDiagnosticTypes:
7555 : {
7556 0 : return (get_OpSetDiagnosticTypes()) == ((aRhs).get_OpSetDiagnosticTypes());
7557 : }
7558 : case TOpWindowOverlayChanged:
7559 : {
7560 0 : return (get_OpWindowOverlayChanged()) == ((aRhs).get_OpWindowOverlayChanged());
7561 : }
7562 : case TOpSetRoot:
7563 : {
7564 0 : return (get_OpSetRoot()) == ((aRhs).get_OpSetRoot());
7565 : }
7566 : case TOpInsertAfter:
7567 : {
7568 0 : return (get_OpInsertAfter()) == ((aRhs).get_OpInsertAfter());
7569 : }
7570 : case TOpPrependChild:
7571 : {
7572 0 : return (get_OpPrependChild()) == ((aRhs).get_OpPrependChild());
7573 : }
7574 : case TOpRemoveChild:
7575 : {
7576 0 : return (get_OpRemoveChild()) == ((aRhs).get_OpRemoveChild());
7577 : }
7578 : case TOpRepositionChild:
7579 : {
7580 0 : return (get_OpRepositionChild()) == ((aRhs).get_OpRepositionChild());
7581 : }
7582 : case TOpRaiseToTopChild:
7583 : {
7584 0 : return (get_OpRaiseToTopChild()) == ((aRhs).get_OpRaiseToTopChild());
7585 : }
7586 : case TOpAttachCompositable:
7587 : {
7588 0 : return (get_OpAttachCompositable()) == ((aRhs).get_OpAttachCompositable());
7589 : }
7590 : case TOpAttachAsyncCompositable:
7591 : {
7592 0 : return (get_OpAttachAsyncCompositable()) == ((aRhs).get_OpAttachAsyncCompositable());
7593 : }
7594 : case TCompositableOperation:
7595 : {
7596 0 : return (get_CompositableOperation()) == ((aRhs).get_CompositableOperation());
7597 : }
7598 : default:
7599 : {
7600 0 : mozilla::ipc::LogicError("unreached");
7601 0 : return false;
7602 : }
7603 : }
7604 : }
7605 :
7606 0 : auto Edit::get(OpCreatePaintedLayer* aOutValue) const -> void
7607 : {
7608 0 : (*(aOutValue)) = get_OpCreatePaintedLayer();
7609 0 : }
7610 :
7611 0 : auto Edit::get(OpCreateContainerLayer* aOutValue) const -> void
7612 : {
7613 0 : (*(aOutValue)) = get_OpCreateContainerLayer();
7614 0 : }
7615 :
7616 0 : auto Edit::get(OpCreateImageLayer* aOutValue) const -> void
7617 : {
7618 0 : (*(aOutValue)) = get_OpCreateImageLayer();
7619 0 : }
7620 :
7621 0 : auto Edit::get(OpCreateColorLayer* aOutValue) const -> void
7622 : {
7623 0 : (*(aOutValue)) = get_OpCreateColorLayer();
7624 0 : }
7625 :
7626 0 : auto Edit::get(OpCreateTextLayer* aOutValue) const -> void
7627 : {
7628 0 : (*(aOutValue)) = get_OpCreateTextLayer();
7629 0 : }
7630 :
7631 0 : auto Edit::get(OpCreateBorderLayer* aOutValue) const -> void
7632 : {
7633 0 : (*(aOutValue)) = get_OpCreateBorderLayer();
7634 0 : }
7635 :
7636 0 : auto Edit::get(OpCreateCanvasLayer* aOutValue) const -> void
7637 : {
7638 0 : (*(aOutValue)) = get_OpCreateCanvasLayer();
7639 0 : }
7640 :
7641 0 : auto Edit::get(OpCreateRefLayer* aOutValue) const -> void
7642 : {
7643 0 : (*(aOutValue)) = get_OpCreateRefLayer();
7644 0 : }
7645 :
7646 0 : auto Edit::get(OpSetDiagnosticTypes* aOutValue) const -> void
7647 : {
7648 0 : (*(aOutValue)) = get_OpSetDiagnosticTypes();
7649 0 : }
7650 :
7651 0 : auto Edit::get(OpWindowOverlayChanged* aOutValue) const -> void
7652 : {
7653 0 : (*(aOutValue)) = get_OpWindowOverlayChanged();
7654 0 : }
7655 :
7656 0 : auto Edit::get(OpSetRoot* aOutValue) const -> void
7657 : {
7658 0 : (*(aOutValue)) = get_OpSetRoot();
7659 0 : }
7660 :
7661 0 : auto Edit::get(OpInsertAfter* aOutValue) const -> void
7662 : {
7663 0 : (*(aOutValue)) = get_OpInsertAfter();
7664 0 : }
7665 :
7666 0 : auto Edit::get(OpPrependChild* aOutValue) const -> void
7667 : {
7668 0 : (*(aOutValue)) = get_OpPrependChild();
7669 0 : }
7670 :
7671 0 : auto Edit::get(OpRemoveChild* aOutValue) const -> void
7672 : {
7673 0 : (*(aOutValue)) = get_OpRemoveChild();
7674 0 : }
7675 :
7676 0 : auto Edit::get(OpRepositionChild* aOutValue) const -> void
7677 : {
7678 0 : (*(aOutValue)) = get_OpRepositionChild();
7679 0 : }
7680 :
7681 0 : auto Edit::get(OpRaiseToTopChild* aOutValue) const -> void
7682 : {
7683 0 : (*(aOutValue)) = get_OpRaiseToTopChild();
7684 0 : }
7685 :
7686 0 : auto Edit::get(OpAttachCompositable* aOutValue) const -> void
7687 : {
7688 0 : (*(aOutValue)) = get_OpAttachCompositable();
7689 0 : }
7690 :
7691 0 : auto Edit::get(OpAttachAsyncCompositable* aOutValue) const -> void
7692 : {
7693 0 : (*(aOutValue)) = get_OpAttachAsyncCompositable();
7694 0 : }
7695 :
7696 0 : auto Edit::get(CompositableOperation* aOutValue) const -> void
7697 : {
7698 0 : (*(aOutValue)) = get_CompositableOperation();
7699 0 : }
7700 :
7701 : } // namespace layers
7702 : } // namespace mozilla
7703 :
7704 : //-----------------------------------------------------------------------------
7705 : // Method definitions for the IPDL type |union OpDestroy|
7706 : //
7707 : namespace mozilla {
7708 : namespace layers {
7709 33 : auto OpDestroy::MaybeDestroy(Type aNewType) -> bool
7710 : {
7711 33 : if ((mType) == (T__None)) {
7712 2 : return true;
7713 : }
7714 31 : if ((mType) == (aNewType)) {
7715 0 : return false;
7716 : }
7717 31 : switch (mType) {
7718 : case TPTextureParent:
7719 : {
7720 2 : (ptr_PTextureParent())->~PTextureParent__tdef();
7721 2 : break;
7722 : }
7723 : case TPTextureChild:
7724 : {
7725 10 : (ptr_PTextureChild())->~PTextureChild__tdef();
7726 10 : break;
7727 : }
7728 : case TCompositableHandle:
7729 : {
7730 19 : (ptr_CompositableHandle())->~CompositableHandle__tdef();
7731 19 : break;
7732 : }
7733 : default:
7734 : {
7735 0 : mozilla::ipc::LogicError("not reached");
7736 0 : break;
7737 : }
7738 : }
7739 31 : return true;
7740 : }
7741 :
7742 0 : MOZ_IMPLICIT OpDestroy::OpDestroy(PTextureParent* aOther)
7743 : {
7744 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>(aOther));
7745 0 : mType = TPTextureParent;
7746 0 : }
7747 :
7748 6 : MOZ_IMPLICIT OpDestroy::OpDestroy(PTextureChild* aOther)
7749 : {
7750 6 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>(aOther));
7751 6 : mType = TPTextureChild;
7752 6 : }
7753 :
7754 19 : MOZ_IMPLICIT OpDestroy::OpDestroy(const CompositableHandle& aOther)
7755 : {
7756 19 : new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle(aOther);
7757 19 : mType = TCompositableHandle;
7758 19 : }
7759 :
7760 4 : MOZ_IMPLICIT OpDestroy::OpDestroy(const OpDestroy& aOther)
7761 : {
7762 4 : (aOther).AssertSanity();
7763 4 : switch ((aOther).type()) {
7764 : case TPTextureParent:
7765 : {
7766 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*(const_cast<PTextureParent*>((aOther).get_PTextureParent()));
7767 0 : break;
7768 : }
7769 : case TPTextureChild:
7770 : {
7771 4 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*(const_cast<PTextureChild*>((aOther).get_PTextureChild()));
7772 4 : break;
7773 : }
7774 : case TCompositableHandle:
7775 : {
7776 0 : new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle((aOther).get_CompositableHandle());
7777 0 : break;
7778 : }
7779 : case T__None:
7780 : {
7781 0 : break;
7782 : }
7783 : default:
7784 : {
7785 0 : mozilla::ipc::LogicError("unreached");
7786 0 : return;
7787 : }
7788 : }
7789 4 : mType = (aOther).type();
7790 : }
7791 :
7792 62 : OpDestroy::~OpDestroy()
7793 : {
7794 31 : static_cast<void>(MaybeDestroy(T__None));
7795 31 : }
7796 :
7797 2 : auto OpDestroy::operator=(PTextureParent* aRhs) -> OpDestroy&
7798 : {
7799 2 : if (MaybeDestroy(TPTextureParent)) {
7800 2 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
7801 : }
7802 2 : (*(ptr_PTextureParent())) = const_cast<PTextureParent*>(aRhs);
7803 2 : mType = TPTextureParent;
7804 2 : return (*(this));
7805 : }
7806 :
7807 0 : auto OpDestroy::operator=(PTextureChild* aRhs) -> OpDestroy&
7808 : {
7809 0 : if (MaybeDestroy(TPTextureChild)) {
7810 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
7811 : }
7812 0 : (*(ptr_PTextureChild())) = const_cast<PTextureChild*>(aRhs);
7813 0 : mType = TPTextureChild;
7814 0 : return (*(this));
7815 : }
7816 :
7817 0 : auto OpDestroy::operator=(const CompositableHandle& aRhs) -> OpDestroy&
7818 : {
7819 0 : if (MaybeDestroy(TCompositableHandle)) {
7820 0 : new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle;
7821 : }
7822 0 : (*(ptr_CompositableHandle())) = aRhs;
7823 0 : mType = TCompositableHandle;
7824 0 : return (*(this));
7825 : }
7826 :
7827 0 : auto OpDestroy::operator=(const OpDestroy& aRhs) -> OpDestroy&
7828 : {
7829 0 : (aRhs).AssertSanity();
7830 0 : Type t = (aRhs).type();
7831 0 : switch (t) {
7832 : case TPTextureParent:
7833 : {
7834 0 : if (MaybeDestroy(t)) {
7835 0 : new (mozilla::KnownNotNull, ptr_PTextureParent()) PTextureParent*;
7836 : }
7837 0 : (*(ptr_PTextureParent())) = const_cast<PTextureParent*>((aRhs).get_PTextureParent());
7838 0 : break;
7839 : }
7840 : case TPTextureChild:
7841 : {
7842 0 : if (MaybeDestroy(t)) {
7843 0 : new (mozilla::KnownNotNull, ptr_PTextureChild()) PTextureChild*;
7844 : }
7845 0 : (*(ptr_PTextureChild())) = const_cast<PTextureChild*>((aRhs).get_PTextureChild());
7846 0 : break;
7847 : }
7848 : case TCompositableHandle:
7849 : {
7850 0 : if (MaybeDestroy(t)) {
7851 0 : new (mozilla::KnownNotNull, ptr_CompositableHandle()) CompositableHandle;
7852 : }
7853 0 : (*(ptr_CompositableHandle())) = (aRhs).get_CompositableHandle();
7854 0 : break;
7855 : }
7856 : case T__None:
7857 : {
7858 0 : static_cast<void>(MaybeDestroy(t));
7859 0 : break;
7860 : }
7861 : default:
7862 : {
7863 0 : mozilla::ipc::LogicError("unreached");
7864 0 : break;
7865 : }
7866 : }
7867 0 : mType = t;
7868 0 : return (*(this));
7869 : }
7870 :
7871 0 : auto OpDestroy::operator==(PTextureParent* aRhs) const -> bool
7872 : {
7873 0 : return (get_PTextureParent()) == (aRhs);
7874 : }
7875 :
7876 0 : auto OpDestroy::operator==(PTextureChild* aRhs) const -> bool
7877 : {
7878 0 : return (get_PTextureChild()) == (aRhs);
7879 : }
7880 :
7881 0 : auto OpDestroy::operator==(const CompositableHandle& aRhs) const -> bool
7882 : {
7883 0 : return (get_CompositableHandle()) == (aRhs);
7884 : }
7885 :
7886 0 : auto OpDestroy::operator==(const OpDestroy& aRhs) const -> bool
7887 : {
7888 0 : if ((type()) != ((aRhs).type())) {
7889 0 : return false;
7890 : }
7891 :
7892 0 : switch (type()) {
7893 : case TPTextureParent:
7894 : {
7895 0 : return (get_PTextureParent()) == ((aRhs).get_PTextureParent());
7896 : }
7897 : case TPTextureChild:
7898 : {
7899 0 : return (get_PTextureChild()) == ((aRhs).get_PTextureChild());
7900 : }
7901 : case TCompositableHandle:
7902 : {
7903 0 : return (get_CompositableHandle()) == ((aRhs).get_CompositableHandle());
7904 : }
7905 : default:
7906 : {
7907 0 : mozilla::ipc::LogicError("unreached");
7908 0 : return false;
7909 : }
7910 : }
7911 : }
7912 :
7913 0 : auto OpDestroy::get(PTextureParent** aOutValue) const -> void
7914 : {
7915 0 : (*(aOutValue)) = get_PTextureParent();
7916 0 : }
7917 :
7918 0 : auto OpDestroy::get(PTextureChild** aOutValue) const -> void
7919 : {
7920 0 : (*(aOutValue)) = get_PTextureChild();
7921 0 : }
7922 :
7923 0 : auto OpDestroy::get(CompositableHandle* aOutValue) const -> void
7924 : {
7925 0 : (*(aOutValue)) = get_CompositableHandle();
7926 0 : }
7927 :
7928 : } // namespace layers
7929 : } // namespace mozilla
7930 :
7931 : //-----------------------------------------------------------------------------
7932 : // Method definitions for the IPDL type |struct OpContentBufferSwap|
7933 : //
7934 : namespace mozilla {
7935 : namespace layers {
7936 0 : MOZ_IMPLICIT OpContentBufferSwap::OpContentBufferSwap() :
7937 : compositable_(),
7938 0 : frontUpdatedRegion_()
7939 : {
7940 0 : Init();
7941 0 : }
7942 :
7943 0 : OpContentBufferSwap::~OpContentBufferSwap()
7944 : {
7945 0 : }
7946 :
7947 0 : auto OpContentBufferSwap::operator==(const OpContentBufferSwap& _o) const -> bool
7948 : {
7949 0 : if ((!((compositable()) == ((_o).compositable())))) {
7950 0 : return false;
7951 : }
7952 0 : if ((!((frontUpdatedRegion()) == ((_o).frontUpdatedRegion())))) {
7953 0 : return false;
7954 : }
7955 0 : return true;
7956 : }
7957 :
7958 0 : auto OpContentBufferSwap::operator!=(const OpContentBufferSwap& _o) const -> bool
7959 : {
7960 0 : return (!(operator==(_o)));
7961 : }
7962 :
7963 0 : auto OpContentBufferSwap::Init() -> void
7964 : {
7965 0 : }
7966 :
7967 0 : auto OpContentBufferSwap::Assign(
7968 : const CompositableHandle& _compositable,
7969 : const nsIntRegion& _frontUpdatedRegion) -> void
7970 : {
7971 0 : compositable_ = _compositable;
7972 0 : frontUpdatedRegion_ = _frontUpdatedRegion;
7973 0 : }
7974 :
7975 : } // namespace layers
7976 : } // namespace mozilla
7977 :
7978 : //-----------------------------------------------------------------------------
7979 : // Method definitions for the IPDL type |struct ImageCompositeNotification|
7980 : //
7981 : namespace mozilla {
7982 : namespace layers {
7983 0 : MOZ_IMPLICIT ImageCompositeNotification::ImageCompositeNotification() :
7984 : compositable_(),
7985 : imageTimeStamp_(),
7986 : firstCompositeTimeStamp_(),
7987 : frameID_(),
7988 0 : producerID_()
7989 : {
7990 0 : Init();
7991 0 : }
7992 :
7993 0 : ImageCompositeNotification::~ImageCompositeNotification()
7994 : {
7995 0 : }
7996 :
7997 0 : auto ImageCompositeNotification::operator==(const ImageCompositeNotification& _o) const -> bool
7998 : {
7999 0 : if ((!((compositable()) == ((_o).compositable())))) {
8000 0 : return false;
8001 : }
8002 0 : if ((!((imageTimeStamp()) == ((_o).imageTimeStamp())))) {
8003 0 : return false;
8004 : }
8005 0 : if ((!((firstCompositeTimeStamp()) == ((_o).firstCompositeTimeStamp())))) {
8006 0 : return false;
8007 : }
8008 0 : if ((!((frameID()) == ((_o).frameID())))) {
8009 0 : return false;
8010 : }
8011 0 : if ((!((producerID()) == ((_o).producerID())))) {
8012 0 : return false;
8013 : }
8014 0 : return true;
8015 : }
8016 :
8017 0 : auto ImageCompositeNotification::operator!=(const ImageCompositeNotification& _o) const -> bool
8018 : {
8019 0 : return (!(operator==(_o)));
8020 : }
8021 :
8022 0 : auto ImageCompositeNotification::Init() -> void
8023 : {
8024 0 : }
8025 :
8026 0 : auto ImageCompositeNotification::Assign(
8027 : const CompositableHandle& _compositable,
8028 : const TimeStamp& _imageTimeStamp,
8029 : const TimeStamp& _firstCompositeTimeStamp,
8030 : const uint32_t& _frameID,
8031 : const uint32_t& _producerID) -> void
8032 : {
8033 0 : compositable_ = _compositable;
8034 0 : imageTimeStamp_ = _imageTimeStamp;
8035 0 : firstCompositeTimeStamp_ = _firstCompositeTimeStamp;
8036 0 : frameID_ = _frameID;
8037 0 : producerID_ = _producerID;
8038 0 : }
8039 :
8040 : } // namespace layers
8041 : } // namespace mozilla
8042 :
8043 : //-----------------------------------------------------------------------------
8044 : // Method definitions for the IPDL type |union AsyncParentMessageData|
8045 : //
8046 : namespace mozilla {
8047 : namespace layers {
8048 0 : auto AsyncParentMessageData::MaybeDestroy(Type aNewType) -> bool
8049 : {
8050 0 : if ((mType) == (T__None)) {
8051 0 : return true;
8052 : }
8053 0 : if ((mType) == (aNewType)) {
8054 0 : return false;
8055 : }
8056 0 : switch (mType) {
8057 : case TOpNotifyNotUsed:
8058 : {
8059 0 : (ptr_OpNotifyNotUsed())->~OpNotifyNotUsed__tdef();
8060 0 : break;
8061 : }
8062 : default:
8063 : {
8064 0 : mozilla::ipc::LogicError("not reached");
8065 0 : break;
8066 : }
8067 : }
8068 0 : return true;
8069 : }
8070 :
8071 0 : MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const OpNotifyNotUsed& aOther)
8072 : {
8073 0 : new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed(aOther);
8074 0 : mType = TOpNotifyNotUsed;
8075 0 : }
8076 :
8077 0 : MOZ_IMPLICIT AsyncParentMessageData::AsyncParentMessageData(const AsyncParentMessageData& aOther)
8078 : {
8079 0 : (aOther).AssertSanity();
8080 0 : switch ((aOther).type()) {
8081 : case TOpNotifyNotUsed:
8082 : {
8083 0 : new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed((aOther).get_OpNotifyNotUsed());
8084 0 : break;
8085 : }
8086 : case T__None:
8087 : {
8088 0 : break;
8089 : }
8090 : default:
8091 : {
8092 0 : mozilla::ipc::LogicError("unreached");
8093 0 : return;
8094 : }
8095 : }
8096 0 : mType = (aOther).type();
8097 : }
8098 :
8099 0 : AsyncParentMessageData::~AsyncParentMessageData()
8100 : {
8101 0 : static_cast<void>(MaybeDestroy(T__None));
8102 0 : }
8103 :
8104 0 : auto AsyncParentMessageData::operator=(const OpNotifyNotUsed& aRhs) -> AsyncParentMessageData&
8105 : {
8106 0 : if (MaybeDestroy(TOpNotifyNotUsed)) {
8107 0 : new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed;
8108 : }
8109 0 : (*(ptr_OpNotifyNotUsed())) = aRhs;
8110 0 : mType = TOpNotifyNotUsed;
8111 0 : return (*(this));
8112 : }
8113 :
8114 0 : auto AsyncParentMessageData::operator=(const AsyncParentMessageData& aRhs) -> AsyncParentMessageData&
8115 : {
8116 0 : (aRhs).AssertSanity();
8117 0 : Type t = (aRhs).type();
8118 0 : switch (t) {
8119 : case TOpNotifyNotUsed:
8120 : {
8121 0 : if (MaybeDestroy(t)) {
8122 0 : new (mozilla::KnownNotNull, ptr_OpNotifyNotUsed()) OpNotifyNotUsed;
8123 : }
8124 0 : (*(ptr_OpNotifyNotUsed())) = (aRhs).get_OpNotifyNotUsed();
8125 0 : break;
8126 : }
8127 : case T__None:
8128 : {
8129 0 : static_cast<void>(MaybeDestroy(t));
8130 0 : break;
8131 : }
8132 : default:
8133 : {
8134 0 : mozilla::ipc::LogicError("unreached");
8135 0 : break;
8136 : }
8137 : }
8138 0 : mType = t;
8139 0 : return (*(this));
8140 : }
8141 :
8142 0 : auto AsyncParentMessageData::operator==(const OpNotifyNotUsed& aRhs) const -> bool
8143 : {
8144 0 : return (get_OpNotifyNotUsed()) == (aRhs);
8145 : }
8146 :
8147 0 : auto AsyncParentMessageData::operator==(const AsyncParentMessageData& aRhs) const -> bool
8148 : {
8149 0 : if ((type()) != ((aRhs).type())) {
8150 0 : return false;
8151 : }
8152 :
8153 0 : switch (type()) {
8154 : case TOpNotifyNotUsed:
8155 : {
8156 0 : return (get_OpNotifyNotUsed()) == ((aRhs).get_OpNotifyNotUsed());
8157 : }
8158 : default:
8159 : {
8160 0 : mozilla::ipc::LogicError("unreached");
8161 0 : return false;
8162 : }
8163 : }
8164 : }
8165 :
8166 0 : auto AsyncParentMessageData::get(OpNotifyNotUsed* aOutValue) const -> void
8167 : {
8168 0 : (*(aOutValue)) = get_OpNotifyNotUsed();
8169 0 : }
8170 :
8171 : } // namespace layers
8172 : } // namespace mozilla
8173 :
8174 : //-----------------------------------------------------------------------------
8175 : // Method definitions for the IPDL type |struct PaintTiming|
8176 : //
8177 : namespace mozilla {
8178 : namespace layers {
8179 2 : MOZ_IMPLICIT PaintTiming::PaintTiming() :
8180 : serializeMs_(),
8181 : sendMs_(),
8182 : dlMs_(),
8183 : flbMs_(),
8184 2 : rasterMs_()
8185 : {
8186 2 : Init();
8187 2 : }
8188 :
8189 0 : PaintTiming::~PaintTiming()
8190 : {
8191 0 : }
8192 :
8193 0 : auto PaintTiming::operator==(const PaintTiming& _o) const -> bool
8194 : {
8195 0 : if ((!((serializeMs()) == ((_o).serializeMs())))) {
8196 0 : return false;
8197 : }
8198 0 : if ((!((sendMs()) == ((_o).sendMs())))) {
8199 0 : return false;
8200 : }
8201 0 : if ((!((dlMs()) == ((_o).dlMs())))) {
8202 0 : return false;
8203 : }
8204 0 : if ((!((flbMs()) == ((_o).flbMs())))) {
8205 0 : return false;
8206 : }
8207 0 : if ((!((rasterMs()) == ((_o).rasterMs())))) {
8208 0 : return false;
8209 : }
8210 0 : return true;
8211 : }
8212 :
8213 0 : auto PaintTiming::operator!=(const PaintTiming& _o) const -> bool
8214 : {
8215 0 : return (!(operator==(_o)));
8216 : }
8217 :
8218 2 : auto PaintTiming::Init() -> void
8219 : {
8220 2 : }
8221 :
8222 0 : auto PaintTiming::Assign(
8223 : const float& _serializeMs,
8224 : const float& _sendMs,
8225 : const float& _dlMs,
8226 : const float& _flbMs,
8227 : const float& _rasterMs) -> void
8228 : {
8229 0 : serializeMs_ = _serializeMs;
8230 0 : sendMs_ = _sendMs;
8231 0 : dlMs_ = _dlMs;
8232 0 : flbMs_ = _flbMs;
8233 0 : rasterMs_ = _rasterMs;
8234 0 : }
8235 :
8236 : } // namespace layers
8237 : } // namespace mozilla
8238 :
8239 : //-----------------------------------------------------------------------------
8240 : // Method definitions for the IPDL type |struct TransactionInfo|
8241 : //
8242 : namespace mozilla {
8243 : namespace layers {
8244 57 : MOZ_IMPLICIT TransactionInfo::TransactionInfo() :
8245 : fwdTransactionId_(),
8246 : id_(),
8247 : isFirstPaint_(),
8248 : focusTarget_(),
8249 : scheduleComposite_(),
8250 : paintSequenceNumber_(),
8251 : isRepeatTransaction_(),
8252 57 : transactionStart_()
8253 : {
8254 57 : Init();
8255 57 : }
8256 :
8257 57 : TransactionInfo::~TransactionInfo()
8258 : {
8259 57 : }
8260 :
8261 0 : auto TransactionInfo::operator==(const TransactionInfo& _o) const -> bool
8262 : {
8263 0 : if ((!((cset()) == ((_o).cset())))) {
8264 0 : return false;
8265 : }
8266 0 : if ((!((setSimpleAttrs()) == ((_o).setSimpleAttrs())))) {
8267 0 : return false;
8268 : }
8269 0 : if ((!((setAttrs()) == ((_o).setAttrs())))) {
8270 0 : return false;
8271 : }
8272 0 : if ((!((paints()) == ((_o).paints())))) {
8273 0 : return false;
8274 : }
8275 0 : if ((!((toDestroy()) == ((_o).toDestroy())))) {
8276 0 : return false;
8277 : }
8278 0 : if ((!((fwdTransactionId()) == ((_o).fwdTransactionId())))) {
8279 0 : return false;
8280 : }
8281 0 : if ((!((id()) == ((_o).id())))) {
8282 0 : return false;
8283 : }
8284 0 : if ((!((targetConfig()) == ((_o).targetConfig())))) {
8285 0 : return false;
8286 : }
8287 0 : if ((!((plugins()) == ((_o).plugins())))) {
8288 0 : return false;
8289 : }
8290 0 : if ((!((isFirstPaint()) == ((_o).isFirstPaint())))) {
8291 0 : return false;
8292 : }
8293 0 : if ((!((focusTarget()) == ((_o).focusTarget())))) {
8294 0 : return false;
8295 : }
8296 0 : if ((!((scheduleComposite()) == ((_o).scheduleComposite())))) {
8297 0 : return false;
8298 : }
8299 0 : if ((!((paintSequenceNumber()) == ((_o).paintSequenceNumber())))) {
8300 0 : return false;
8301 : }
8302 0 : if ((!((isRepeatTransaction()) == ((_o).isRepeatTransaction())))) {
8303 0 : return false;
8304 : }
8305 0 : if ((!((transactionStart()) == ((_o).transactionStart())))) {
8306 0 : return false;
8307 : }
8308 0 : return true;
8309 : }
8310 :
8311 0 : auto TransactionInfo::operator!=(const TransactionInfo& _o) const -> bool
8312 : {
8313 0 : return (!(operator==(_o)));
8314 : }
8315 :
8316 57 : auto TransactionInfo::Init() -> void
8317 : {
8318 57 : }
8319 :
8320 0 : auto TransactionInfo::Assign(
8321 : const nsTArray<Edit>& _cset,
8322 : const nsTArray<OpSetSimpleLayerAttributes>& _setSimpleAttrs,
8323 : const nsTArray<OpSetLayerAttributes>& _setAttrs,
8324 : const nsTArray<CompositableOperation>& _paints,
8325 : const nsTArray<OpDestroy>& _toDestroy,
8326 : const uint64_t& _fwdTransactionId,
8327 : const uint64_t& _id,
8328 : const TargetConfig& _targetConfig,
8329 : const nsTArray<PluginWindowData>& _plugins,
8330 : const bool& _isFirstPaint,
8331 : const FocusTarget& _focusTarget,
8332 : const bool& _scheduleComposite,
8333 : const uint32_t& _paintSequenceNumber,
8334 : const bool& _isRepeatTransaction,
8335 : const TimeStamp& _transactionStart) -> void
8336 : {
8337 0 : cset_ = _cset;
8338 0 : setSimpleAttrs_ = _setSimpleAttrs;
8339 0 : setAttrs_ = _setAttrs;
8340 0 : paints_ = _paints;
8341 0 : toDestroy_ = _toDestroy;
8342 0 : fwdTransactionId_ = _fwdTransactionId;
8343 0 : id_ = _id;
8344 0 : targetConfig_ = _targetConfig;
8345 0 : plugins_ = _plugins;
8346 0 : isFirstPaint_ = _isFirstPaint;
8347 0 : focusTarget_ = _focusTarget;
8348 0 : scheduleComposite_ = _scheduleComposite;
8349 0 : paintSequenceNumber_ = _paintSequenceNumber;
8350 0 : isRepeatTransaction_ = _isRepeatTransaction;
8351 0 : transactionStart_ = _transactionStart;
8352 0 : }
8353 :
8354 : } // namespace layers
8355 : } // namespace mozilla
8356 :
8357 : //-----------------------------------------------------------------------------
8358 : // Method definitions for the IPDL type |union MaybeTransform|
8359 : //
8360 : namespace mozilla {
8361 : namespace layers {
8362 0 : auto MaybeTransform::MaybeDestroy(Type aNewType) -> bool
8363 : {
8364 0 : if ((mType) == (T__None)) {
8365 0 : return true;
8366 : }
8367 0 : if ((mType) == (aNewType)) {
8368 0 : return false;
8369 : }
8370 0 : switch (mType) {
8371 : case TMatrix4x4:
8372 : {
8373 0 : (ptr_Matrix4x4())->~Matrix4x4__tdef();
8374 0 : break;
8375 : }
8376 : case Tvoid_t:
8377 : {
8378 0 : (ptr_void_t())->~void_t__tdef();
8379 0 : break;
8380 : }
8381 : default:
8382 : {
8383 0 : mozilla::ipc::LogicError("not reached");
8384 0 : break;
8385 : }
8386 : }
8387 0 : return true;
8388 : }
8389 :
8390 0 : MOZ_IMPLICIT MaybeTransform::MaybeTransform(const Matrix4x4& aOther)
8391 : {
8392 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4(aOther);
8393 0 : mType = TMatrix4x4;
8394 0 : }
8395 :
8396 0 : MOZ_IMPLICIT MaybeTransform::MaybeTransform(const void_t& aOther)
8397 : {
8398 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
8399 0 : mType = Tvoid_t;
8400 0 : }
8401 :
8402 0 : MOZ_IMPLICIT MaybeTransform::MaybeTransform(const MaybeTransform& aOther)
8403 : {
8404 0 : (aOther).AssertSanity();
8405 0 : switch ((aOther).type()) {
8406 : case TMatrix4x4:
8407 : {
8408 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4((aOther).get_Matrix4x4());
8409 0 : break;
8410 : }
8411 : case Tvoid_t:
8412 : {
8413 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
8414 0 : break;
8415 : }
8416 : case T__None:
8417 : {
8418 0 : break;
8419 : }
8420 : default:
8421 : {
8422 0 : mozilla::ipc::LogicError("unreached");
8423 0 : return;
8424 : }
8425 : }
8426 0 : mType = (aOther).type();
8427 : }
8428 :
8429 0 : MaybeTransform::~MaybeTransform()
8430 : {
8431 0 : static_cast<void>(MaybeDestroy(T__None));
8432 0 : }
8433 :
8434 0 : auto MaybeTransform::operator=(const Matrix4x4& aRhs) -> MaybeTransform&
8435 : {
8436 0 : if (MaybeDestroy(TMatrix4x4)) {
8437 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
8438 : }
8439 0 : (*(ptr_Matrix4x4())) = aRhs;
8440 0 : mType = TMatrix4x4;
8441 0 : return (*(this));
8442 : }
8443 :
8444 0 : auto MaybeTransform::operator=(const void_t& aRhs) -> MaybeTransform&
8445 : {
8446 0 : if (MaybeDestroy(Tvoid_t)) {
8447 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
8448 : }
8449 0 : (*(ptr_void_t())) = aRhs;
8450 0 : mType = Tvoid_t;
8451 0 : return (*(this));
8452 : }
8453 :
8454 0 : auto MaybeTransform::operator=(const MaybeTransform& aRhs) -> MaybeTransform&
8455 : {
8456 0 : (aRhs).AssertSanity();
8457 0 : Type t = (aRhs).type();
8458 0 : switch (t) {
8459 : case TMatrix4x4:
8460 : {
8461 0 : if (MaybeDestroy(t)) {
8462 0 : new (mozilla::KnownNotNull, ptr_Matrix4x4()) Matrix4x4;
8463 : }
8464 0 : (*(ptr_Matrix4x4())) = (aRhs).get_Matrix4x4();
8465 0 : break;
8466 : }
8467 : case Tvoid_t:
8468 : {
8469 0 : if (MaybeDestroy(t)) {
8470 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
8471 : }
8472 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
8473 0 : break;
8474 : }
8475 : case T__None:
8476 : {
8477 0 : static_cast<void>(MaybeDestroy(t));
8478 0 : break;
8479 : }
8480 : default:
8481 : {
8482 0 : mozilla::ipc::LogicError("unreached");
8483 0 : break;
8484 : }
8485 : }
8486 0 : mType = t;
8487 0 : return (*(this));
8488 : }
8489 :
8490 0 : auto MaybeTransform::operator==(const Matrix4x4& aRhs) const -> bool
8491 : {
8492 0 : return (get_Matrix4x4()) == (aRhs);
8493 : }
8494 :
8495 0 : auto MaybeTransform::operator==(const void_t& aRhs) const -> bool
8496 : {
8497 0 : return (get_void_t()) == (aRhs);
8498 : }
8499 :
8500 0 : auto MaybeTransform::operator==(const MaybeTransform& aRhs) const -> bool
8501 : {
8502 0 : if ((type()) != ((aRhs).type())) {
8503 0 : return false;
8504 : }
8505 :
8506 0 : switch (type()) {
8507 : case TMatrix4x4:
8508 : {
8509 0 : return (get_Matrix4x4()) == ((aRhs).get_Matrix4x4());
8510 : }
8511 : case Tvoid_t:
8512 : {
8513 0 : return (get_void_t()) == ((aRhs).get_void_t());
8514 : }
8515 : default:
8516 : {
8517 0 : mozilla::ipc::LogicError("unreached");
8518 0 : return false;
8519 : }
8520 : }
8521 : }
8522 :
8523 0 : auto MaybeTransform::get(Matrix4x4* aOutValue) const -> void
8524 : {
8525 0 : (*(aOutValue)) = get_Matrix4x4();
8526 0 : }
8527 :
8528 0 : auto MaybeTransform::get(void_t* aOutValue) const -> void
8529 : {
8530 0 : (*(aOutValue)) = get_void_t();
8531 0 : }
8532 :
8533 : } // namespace layers
8534 : } // namespace mozilla
|
