1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/layers/PLayers.h"
8 :
9 : namespace mozilla {
10 : namespace layers {
11 : namespace PLayers {
12 :
13 : bool
14 0 : Transition(
15 : State from,
16 : mozilla::ipc::Trigger trigger,
17 : State* next)
18 : {
19 0 : switch (from) {
20 : case __Null:
21 : case __Error:
22 0 : if ((Msg___delete____ID) == ((trigger).mMsg)) {
23 0 : (*(next)) = __Dead;
24 0 : return true;
25 : }
26 0 : return (__Null) == (from);
27 : case __Dead:
28 0 : NS_RUNTIMEABORT("__delete__()d actor");
29 0 : return false;
30 : default:
31 0 : NS_RUNTIMEABORT("corrupted actor state");
32 0 : return false;
33 : }
34 : (*(next)) = __Error;
35 : return false;
36 : }
37 :
38 : } // namespace PLayers
39 : } // namespace layers
40 : } // namespace mozilla
41 :
42 : //-----------------------------------------------------------------------------
43 : // Method definitions for the IPDL type |struct OpCreateThebesLayer|
44 : //
45 : namespace mozilla {
46 : namespace layers {
47 0 : OpCreateThebesLayer::OpCreateThebesLayer()
48 : {
49 0 : Init();
50 0 : }
51 :
52 0 : OpCreateThebesLayer::~OpCreateThebesLayer()
53 : {
54 0 : }
55 :
56 : bool
57 0 : OpCreateThebesLayer::operator==(const OpCreateThebesLayer& _o) const
58 : {
59 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
60 0 : return false;
61 : }
62 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
63 0 : return false;
64 : }
65 0 : return true;
66 : }
67 :
68 : void
69 0 : OpCreateThebesLayer::Init()
70 : {
71 0 : }
72 :
73 : void
74 0 : OpCreateThebesLayer::Assign(
75 : PLayerParent* _layerParent,
76 : PLayerChild* _layerChild)
77 : {
78 0 : layerParent_ = _layerParent;
79 0 : layerChild_ = _layerChild;
80 0 : }
81 :
82 : } // namespace layers
83 : } // namespace mozilla
84 :
85 : //-----------------------------------------------------------------------------
86 : // Method definitions for the IPDL type |struct OpCreateContainerLayer|
87 : //
88 : namespace mozilla {
89 : namespace layers {
90 0 : OpCreateContainerLayer::OpCreateContainerLayer()
91 : {
92 0 : Init();
93 0 : }
94 :
95 0 : OpCreateContainerLayer::~OpCreateContainerLayer()
96 : {
97 0 : }
98 :
99 : bool
100 0 : OpCreateContainerLayer::operator==(const OpCreateContainerLayer& _o) const
101 : {
102 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
103 0 : return false;
104 : }
105 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
106 0 : return false;
107 : }
108 0 : return true;
109 : }
110 :
111 : void
112 0 : OpCreateContainerLayer::Init()
113 : {
114 0 : }
115 :
116 : void
117 0 : OpCreateContainerLayer::Assign(
118 : PLayerParent* _layerParent,
119 : PLayerChild* _layerChild)
120 : {
121 0 : layerParent_ = _layerParent;
122 0 : layerChild_ = _layerChild;
123 0 : }
124 :
125 : } // namespace layers
126 : } // namespace mozilla
127 :
128 : //-----------------------------------------------------------------------------
129 : // Method definitions for the IPDL type |struct OpCreateImageLayer|
130 : //
131 : namespace mozilla {
132 : namespace layers {
133 0 : OpCreateImageLayer::OpCreateImageLayer()
134 : {
135 0 : Init();
136 0 : }
137 :
138 0 : OpCreateImageLayer::~OpCreateImageLayer()
139 : {
140 0 : }
141 :
142 : bool
143 0 : OpCreateImageLayer::operator==(const OpCreateImageLayer& _o) const
144 : {
145 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
146 0 : return false;
147 : }
148 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
149 0 : return false;
150 : }
151 0 : return true;
152 : }
153 :
154 : void
155 0 : OpCreateImageLayer::Init()
156 : {
157 0 : }
158 :
159 : void
160 0 : OpCreateImageLayer::Assign(
161 : PLayerParent* _layerParent,
162 : PLayerChild* _layerChild)
163 : {
164 0 : layerParent_ = _layerParent;
165 0 : layerChild_ = _layerChild;
166 0 : }
167 :
168 : } // namespace layers
169 : } // namespace mozilla
170 :
171 : //-----------------------------------------------------------------------------
172 : // Method definitions for the IPDL type |struct OpCreateColorLayer|
173 : //
174 : namespace mozilla {
175 : namespace layers {
176 0 : OpCreateColorLayer::OpCreateColorLayer()
177 : {
178 0 : Init();
179 0 : }
180 :
181 0 : OpCreateColorLayer::~OpCreateColorLayer()
182 : {
183 0 : }
184 :
185 : bool
186 0 : OpCreateColorLayer::operator==(const OpCreateColorLayer& _o) const
187 : {
188 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
189 0 : return false;
190 : }
191 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
192 0 : return false;
193 : }
194 0 : return true;
195 : }
196 :
197 : void
198 0 : OpCreateColorLayer::Init()
199 : {
200 0 : }
201 :
202 : void
203 0 : OpCreateColorLayer::Assign(
204 : PLayerParent* _layerParent,
205 : PLayerChild* _layerChild)
206 : {
207 0 : layerParent_ = _layerParent;
208 0 : layerChild_ = _layerChild;
209 0 : }
210 :
211 : } // namespace layers
212 : } // namespace mozilla
213 :
214 : //-----------------------------------------------------------------------------
215 : // Method definitions for the IPDL type |struct OpCreateCanvasLayer|
216 : //
217 : namespace mozilla {
218 : namespace layers {
219 0 : OpCreateCanvasLayer::OpCreateCanvasLayer()
220 : {
221 0 : Init();
222 0 : }
223 :
224 0 : OpCreateCanvasLayer::~OpCreateCanvasLayer()
225 : {
226 0 : }
227 :
228 : bool
229 0 : OpCreateCanvasLayer::operator==(const OpCreateCanvasLayer& _o) const
230 : {
231 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
232 0 : return false;
233 : }
234 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
235 0 : return false;
236 : }
237 0 : return true;
238 : }
239 :
240 : void
241 0 : OpCreateCanvasLayer::Init()
242 : {
243 0 : }
244 :
245 : void
246 0 : OpCreateCanvasLayer::Assign(
247 : PLayerParent* _layerParent,
248 : PLayerChild* _layerChild)
249 : {
250 0 : layerParent_ = _layerParent;
251 0 : layerChild_ = _layerChild;
252 0 : }
253 :
254 : } // namespace layers
255 : } // namespace mozilla
256 :
257 : //-----------------------------------------------------------------------------
258 : // Method definitions for the IPDL type |struct SurfaceDescriptorD3D10|
259 : //
260 : namespace mozilla {
261 : namespace layers {
262 0 : SurfaceDescriptorD3D10::SurfaceDescriptorD3D10()
263 : {
264 0 : Init();
265 0 : }
266 :
267 0 : SurfaceDescriptorD3D10::~SurfaceDescriptorD3D10()
268 : {
269 0 : }
270 :
271 : bool
272 0 : SurfaceDescriptorD3D10::operator==(const SurfaceDescriptorD3D10& _o) const
273 : {
274 0 : if ((!((handle()) == ((_o).handle())))) {
275 0 : return false;
276 : }
277 0 : return true;
278 : }
279 :
280 : void
281 0 : SurfaceDescriptorD3D10::Init()
282 : {
283 0 : }
284 :
285 : void
286 0 : SurfaceDescriptorD3D10::Assign(const WindowsHandle& _handle)
287 : {
288 0 : handle_ = _handle;
289 0 : }
290 :
291 : } // namespace layers
292 : } // namespace mozilla
293 :
294 : //-----------------------------------------------------------------------------
295 : // Method definitions for the IPDL type |union SurfaceDescriptor|
296 : //
297 : namespace mozilla {
298 : namespace layers {
299 : bool
300 0 : SurfaceDescriptor::MaybeDestroy(Type aNewType)
301 : {
302 0 : if ((mType) == (T__None)) {
303 0 : return true;
304 : }
305 0 : if ((mType) == (aNewType)) {
306 0 : return false;
307 : }
308 0 : switch (mType) {
309 : case TShmem:
310 : {
311 0 : (ptr_Shmem())->~Shmem__tdef();
312 0 : break;
313 : }
314 : case TSurfaceDescriptorD3D10:
315 : {
316 0 : (ptr_SurfaceDescriptorD3D10())->~SurfaceDescriptorD3D10__tdef();
317 0 : break;
318 : }
319 : case TSurfaceDescriptorX11:
320 : {
321 0 : (ptr_SurfaceDescriptorX11())->~SurfaceDescriptorX11__tdef();
322 0 : break;
323 : }
324 : default:
325 : {
326 0 : NS_RUNTIMEABORT("not reached");
327 0 : break;
328 : }
329 : }
330 0 : return true;
331 : }
332 :
333 0 : SurfaceDescriptor::SurfaceDescriptor(Shmem& aOther)
334 : {
335 0 : new (ptr_Shmem()) Shmem(aOther);
336 0 : mType = TShmem;
337 0 : }
338 :
339 0 : SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorD3D10& aOther)
340 : {
341 0 : new (ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10(aOther);
342 0 : mType = TSurfaceDescriptorD3D10;
343 0 : }
344 :
345 0 : SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptorX11& aOther)
346 : {
347 0 : new (ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11(aOther);
348 0 : mType = TSurfaceDescriptorX11;
349 0 : }
350 :
351 0 : SurfaceDescriptor::SurfaceDescriptor(const SurfaceDescriptor& aOther)
352 : {
353 0 : (aOther).AssertSanity();
354 0 : switch ((aOther).type()) {
355 : case TShmem:
356 : {
357 0 : new (ptr_Shmem()) Shmem((aOther).get_Shmem());
358 0 : break;
359 : }
360 : case TSurfaceDescriptorD3D10:
361 : {
362 0 : new (ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10((aOther).get_SurfaceDescriptorD3D10());
363 0 : break;
364 : }
365 : case TSurfaceDescriptorX11:
366 : {
367 0 : new (ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11((aOther).get_SurfaceDescriptorX11());
368 0 : break;
369 : }
370 : case T__None:
371 : {
372 0 : break;
373 : }
374 : default:
375 : {
376 0 : NS_RUNTIMEABORT("unreached");
377 0 : return;
378 : }
379 : }
380 0 : mType = (aOther).type();
381 : }
382 :
383 0 : SurfaceDescriptor::~SurfaceDescriptor()
384 : {
385 0 : MaybeDestroy(T__None);
386 0 : }
387 :
388 : SurfaceDescriptor&
389 0 : SurfaceDescriptor::operator=(Shmem& aRhs)
390 : {
391 0 : if (MaybeDestroy(TShmem)) {
392 0 : new (ptr_Shmem()) Shmem;
393 : }
394 0 : (*(ptr_Shmem())) = aRhs;
395 0 : mType = TShmem;
396 0 : return (*(this));
397 : }
398 :
399 : SurfaceDescriptor&
400 0 : SurfaceDescriptor::operator=(const SurfaceDescriptorD3D10& aRhs)
401 : {
402 0 : if (MaybeDestroy(TSurfaceDescriptorD3D10)) {
403 0 : new (ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
404 : }
405 0 : (*(ptr_SurfaceDescriptorD3D10())) = aRhs;
406 0 : mType = TSurfaceDescriptorD3D10;
407 0 : return (*(this));
408 : }
409 :
410 : SurfaceDescriptor&
411 0 : SurfaceDescriptor::operator=(const SurfaceDescriptorX11& aRhs)
412 : {
413 0 : if (MaybeDestroy(TSurfaceDescriptorX11)) {
414 0 : new (ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
415 : }
416 0 : (*(ptr_SurfaceDescriptorX11())) = aRhs;
417 0 : mType = TSurfaceDescriptorX11;
418 0 : return (*(this));
419 : }
420 :
421 : SurfaceDescriptor&
422 0 : SurfaceDescriptor::operator=(const SurfaceDescriptor& aRhs)
423 : {
424 0 : (aRhs).AssertSanity();
425 0 : Type t = (aRhs).type();
426 0 : switch (t) {
427 : case TShmem:
428 : {
429 0 : if (MaybeDestroy(t)) {
430 0 : new (ptr_Shmem()) Shmem;
431 : }
432 0 : (*(ptr_Shmem())) = (aRhs).get_Shmem();
433 0 : break;
434 : }
435 : case TSurfaceDescriptorD3D10:
436 : {
437 0 : if (MaybeDestroy(t)) {
438 0 : new (ptr_SurfaceDescriptorD3D10()) SurfaceDescriptorD3D10;
439 : }
440 0 : (*(ptr_SurfaceDescriptorD3D10())) = (aRhs).get_SurfaceDescriptorD3D10();
441 0 : break;
442 : }
443 : case TSurfaceDescriptorX11:
444 : {
445 0 : if (MaybeDestroy(t)) {
446 0 : new (ptr_SurfaceDescriptorX11()) SurfaceDescriptorX11;
447 : }
448 0 : (*(ptr_SurfaceDescriptorX11())) = (aRhs).get_SurfaceDescriptorX11();
449 0 : break;
450 : }
451 : case T__None:
452 : {
453 0 : MaybeDestroy(t);
454 0 : break;
455 : }
456 : default:
457 : {
458 0 : NS_RUNTIMEABORT("unreached");
459 0 : break;
460 : }
461 : }
462 0 : mType = t;
463 0 : return (*(this));
464 : }
465 :
466 : bool
467 0 : SurfaceDescriptor::operator==(Shmem& aRhs) const
468 : {
469 0 : return (get_Shmem()) == (aRhs);
470 : }
471 :
472 : bool
473 0 : SurfaceDescriptor::operator==(const SurfaceDescriptorD3D10& aRhs) const
474 : {
475 0 : return (get_SurfaceDescriptorD3D10()) == (aRhs);
476 : }
477 :
478 : bool
479 0 : SurfaceDescriptor::operator==(const SurfaceDescriptorX11& aRhs) const
480 : {
481 0 : return (get_SurfaceDescriptorX11()) == (aRhs);
482 : }
483 :
484 : bool
485 0 : SurfaceDescriptor::operator==(const SurfaceDescriptor& aRhs) const
486 : {
487 0 : if ((type()) != ((aRhs).type())) {
488 0 : return false;
489 : }
490 :
491 0 : switch (type()) {
492 : case TShmem:
493 : {
494 0 : return (get_Shmem()) == ((aRhs).get_Shmem());
495 : }
496 : case TSurfaceDescriptorD3D10:
497 : {
498 0 : return (get_SurfaceDescriptorD3D10()) == ((aRhs).get_SurfaceDescriptorD3D10());
499 : }
500 : case TSurfaceDescriptorX11:
501 : {
502 0 : return (get_SurfaceDescriptorX11()) == ((aRhs).get_SurfaceDescriptorX11());
503 : }
504 : default:
505 : {
506 0 : NS_RUNTIMEABORT("unreached");
507 0 : return false;
508 : }
509 : }
510 : }
511 :
512 : } // namespace layers
513 : } // namespace mozilla
514 :
515 : //-----------------------------------------------------------------------------
516 : // Method definitions for the IPDL type |struct YUVImage|
517 : //
518 : namespace mozilla {
519 : namespace layers {
520 0 : YUVImage::YUVImage()
521 : {
522 0 : Init();
523 0 : }
524 :
525 0 : YUVImage::~YUVImage()
526 : {
527 0 : }
528 :
529 : bool
530 0 : YUVImage::operator==(const YUVImage& _o) const
531 : {
532 0 : if ((!((Ydata()) == ((_o).Ydata())))) {
533 0 : return false;
534 : }
535 0 : if ((!((Udata()) == ((_o).Udata())))) {
536 0 : return false;
537 : }
538 0 : if ((!((Vdata()) == ((_o).Vdata())))) {
539 0 : return false;
540 : }
541 0 : if ((!((picture()) == ((_o).picture())))) {
542 0 : return false;
543 : }
544 0 : return true;
545 : }
546 :
547 : void
548 0 : YUVImage::Init()
549 : {
550 0 : }
551 :
552 : void
553 0 : YUVImage::Assign(
554 : Shmem& _Ydata,
555 : Shmem& _Udata,
556 : Shmem& _Vdata,
557 : const nsIntRect& _picture)
558 : {
559 0 : Ydata_ = _Ydata;
560 0 : Udata_ = _Udata;
561 0 : Vdata_ = _Vdata;
562 0 : picture_ = _picture;
563 0 : }
564 :
565 : } // namespace layers
566 : } // namespace mozilla
567 :
568 : //-----------------------------------------------------------------------------
569 : // Method definitions for the IPDL type |union SharedImage|
570 : //
571 : namespace mozilla {
572 : namespace layers {
573 : bool
574 0 : SharedImage::MaybeDestroy(Type aNewType)
575 : {
576 0 : if ((mType) == (T__None)) {
577 0 : return true;
578 : }
579 0 : if ((mType) == (aNewType)) {
580 0 : return false;
581 : }
582 0 : switch (mType) {
583 : case TSurfaceDescriptor:
584 : {
585 0 : (ptr_SurfaceDescriptor())->~SurfaceDescriptor__tdef();
586 0 : break;
587 : }
588 : case TYUVImage:
589 : {
590 0 : (ptr_YUVImage())->~YUVImage__tdef();
591 0 : break;
592 : }
593 : case Tnull_t:
594 : {
595 0 : (ptr_null_t())->~null_t__tdef();
596 0 : break;
597 : }
598 : default:
599 : {
600 0 : NS_RUNTIMEABORT("not reached");
601 0 : break;
602 : }
603 : }
604 0 : return true;
605 : }
606 :
607 0 : SharedImage::SharedImage(const SurfaceDescriptor& aOther)
608 : {
609 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor(aOther);
610 0 : mType = TSurfaceDescriptor;
611 0 : }
612 :
613 0 : SharedImage::SharedImage(const YUVImage& aOther)
614 : {
615 0 : new (ptr_YUVImage()) YUVImage(aOther);
616 0 : mType = TYUVImage;
617 0 : }
618 :
619 0 : SharedImage::SharedImage(const null_t& aOther)
620 : {
621 0 : new (ptr_null_t()) null_t(aOther);
622 0 : mType = Tnull_t;
623 0 : }
624 :
625 0 : SharedImage::SharedImage(const SharedImage& aOther)
626 : {
627 0 : (aOther).AssertSanity();
628 0 : switch ((aOther).type()) {
629 : case TSurfaceDescriptor:
630 : {
631 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor((aOther).get_SurfaceDescriptor());
632 0 : break;
633 : }
634 : case TYUVImage:
635 : {
636 0 : new (ptr_YUVImage()) YUVImage((aOther).get_YUVImage());
637 0 : break;
638 : }
639 : case Tnull_t:
640 : {
641 0 : new (ptr_null_t()) null_t((aOther).get_null_t());
642 0 : break;
643 : }
644 : case T__None:
645 : {
646 0 : break;
647 : }
648 : default:
649 : {
650 0 : NS_RUNTIMEABORT("unreached");
651 0 : return;
652 : }
653 : }
654 0 : mType = (aOther).type();
655 : }
656 :
657 0 : SharedImage::~SharedImage()
658 : {
659 0 : MaybeDestroy(T__None);
660 0 : }
661 :
662 : SharedImage&
663 0 : SharedImage::operator=(const SurfaceDescriptor& aRhs)
664 : {
665 0 : if (MaybeDestroy(TSurfaceDescriptor)) {
666 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor;
667 : }
668 0 : (*(ptr_SurfaceDescriptor())) = aRhs;
669 0 : mType = TSurfaceDescriptor;
670 0 : return (*(this));
671 : }
672 :
673 : SharedImage&
674 0 : SharedImage::operator=(const YUVImage& aRhs)
675 : {
676 0 : if (MaybeDestroy(TYUVImage)) {
677 0 : new (ptr_YUVImage()) YUVImage;
678 : }
679 0 : (*(ptr_YUVImage())) = aRhs;
680 0 : mType = TYUVImage;
681 0 : return (*(this));
682 : }
683 :
684 : SharedImage&
685 0 : SharedImage::operator=(const null_t& aRhs)
686 : {
687 0 : if (MaybeDestroy(Tnull_t)) {
688 0 : new (ptr_null_t()) null_t;
689 : }
690 0 : (*(ptr_null_t())) = aRhs;
691 0 : mType = Tnull_t;
692 0 : return (*(this));
693 : }
694 :
695 : SharedImage&
696 0 : SharedImage::operator=(const SharedImage& aRhs)
697 : {
698 0 : (aRhs).AssertSanity();
699 0 : Type t = (aRhs).type();
700 0 : switch (t) {
701 : case TSurfaceDescriptor:
702 : {
703 0 : if (MaybeDestroy(t)) {
704 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor;
705 : }
706 0 : (*(ptr_SurfaceDescriptor())) = (aRhs).get_SurfaceDescriptor();
707 0 : break;
708 : }
709 : case TYUVImage:
710 : {
711 0 : if (MaybeDestroy(t)) {
712 0 : new (ptr_YUVImage()) YUVImage;
713 : }
714 0 : (*(ptr_YUVImage())) = (aRhs).get_YUVImage();
715 0 : break;
716 : }
717 : case Tnull_t:
718 : {
719 0 : if (MaybeDestroy(t)) {
720 0 : new (ptr_null_t()) null_t;
721 : }
722 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
723 0 : break;
724 : }
725 : case T__None:
726 : {
727 0 : MaybeDestroy(t);
728 0 : break;
729 : }
730 : default:
731 : {
732 0 : NS_RUNTIMEABORT("unreached");
733 0 : break;
734 : }
735 : }
736 0 : mType = t;
737 0 : return (*(this));
738 : }
739 :
740 : bool
741 0 : SharedImage::operator==(const SurfaceDescriptor& aRhs) const
742 : {
743 0 : return (get_SurfaceDescriptor()) == (aRhs);
744 : }
745 :
746 : bool
747 0 : SharedImage::operator==(const YUVImage& aRhs) const
748 : {
749 0 : return (get_YUVImage()) == (aRhs);
750 : }
751 :
752 : bool
753 0 : SharedImage::operator==(const null_t& aRhs) const
754 : {
755 0 : return (get_null_t()) == (aRhs);
756 : }
757 :
758 : bool
759 0 : SharedImage::operator==(const SharedImage& aRhs) const
760 : {
761 0 : if ((type()) != ((aRhs).type())) {
762 0 : return false;
763 : }
764 :
765 0 : switch (type()) {
766 : case TSurfaceDescriptor:
767 : {
768 0 : return (get_SurfaceDescriptor()) == ((aRhs).get_SurfaceDescriptor());
769 : }
770 : case TYUVImage:
771 : {
772 0 : return (get_YUVImage()) == ((aRhs).get_YUVImage());
773 : }
774 : case Tnull_t:
775 : {
776 0 : return (get_null_t()) == ((aRhs).get_null_t());
777 : }
778 : default:
779 : {
780 0 : NS_RUNTIMEABORT("unreached");
781 0 : return false;
782 : }
783 : }
784 : }
785 :
786 : } // namespace layers
787 : } // namespace mozilla
788 :
789 : //-----------------------------------------------------------------------------
790 : // Method definitions for the IPDL type |struct ThebesBuffer|
791 : //
792 : namespace mozilla {
793 : namespace layers {
794 0 : ThebesBuffer::ThebesBuffer()
795 : {
796 0 : Init();
797 0 : }
798 :
799 0 : ThebesBuffer::~ThebesBuffer()
800 : {
801 0 : }
802 :
803 : bool
804 0 : ThebesBuffer::operator==(const ThebesBuffer& _o) const
805 : {
806 0 : if ((!((buffer()) == ((_o).buffer())))) {
807 0 : return false;
808 : }
809 0 : if ((!((rect()) == ((_o).rect())))) {
810 0 : return false;
811 : }
812 0 : if ((!((rotation()) == ((_o).rotation())))) {
813 0 : return false;
814 : }
815 0 : return true;
816 : }
817 :
818 : void
819 0 : ThebesBuffer::Init()
820 : {
821 0 : }
822 :
823 : void
824 0 : ThebesBuffer::Assign(
825 : const SurfaceDescriptor& _buffer,
826 : const nsIntRect& _rect,
827 : const nsIntPoint& _rotation)
828 : {
829 0 : buffer_ = _buffer;
830 0 : rect_ = _rect;
831 0 : rotation_ = _rotation;
832 0 : }
833 :
834 : } // namespace layers
835 : } // namespace mozilla
836 :
837 : //-----------------------------------------------------------------------------
838 : // Method definitions for the IPDL type |union OptionalThebesBuffer|
839 : //
840 : namespace mozilla {
841 : namespace layers {
842 : bool
843 0 : OptionalThebesBuffer::MaybeDestroy(Type aNewType)
844 : {
845 0 : if ((mType) == (T__None)) {
846 0 : return true;
847 : }
848 0 : if ((mType) == (aNewType)) {
849 0 : return false;
850 : }
851 0 : switch (mType) {
852 : case TThebesBuffer:
853 : {
854 0 : (ptr_ThebesBuffer())->~ThebesBuffer__tdef();
855 0 : break;
856 : }
857 : case Tnull_t:
858 : {
859 0 : (ptr_null_t())->~null_t__tdef();
860 0 : break;
861 : }
862 : default:
863 : {
864 0 : NS_RUNTIMEABORT("not reached");
865 0 : break;
866 : }
867 : }
868 0 : return true;
869 : }
870 :
871 0 : OptionalThebesBuffer::OptionalThebesBuffer(const ThebesBuffer& aOther)
872 : {
873 0 : new (ptr_ThebesBuffer()) ThebesBuffer(aOther);
874 0 : mType = TThebesBuffer;
875 0 : }
876 :
877 0 : OptionalThebesBuffer::OptionalThebesBuffer(const null_t& aOther)
878 : {
879 0 : new (ptr_null_t()) null_t(aOther);
880 0 : mType = Tnull_t;
881 0 : }
882 :
883 0 : OptionalThebesBuffer::OptionalThebesBuffer(const OptionalThebesBuffer& aOther)
884 : {
885 0 : (aOther).AssertSanity();
886 0 : switch ((aOther).type()) {
887 : case TThebesBuffer:
888 : {
889 0 : new (ptr_ThebesBuffer()) ThebesBuffer((aOther).get_ThebesBuffer());
890 0 : break;
891 : }
892 : case Tnull_t:
893 : {
894 0 : new (ptr_null_t()) null_t((aOther).get_null_t());
895 0 : break;
896 : }
897 : case T__None:
898 : {
899 0 : break;
900 : }
901 : default:
902 : {
903 0 : NS_RUNTIMEABORT("unreached");
904 0 : return;
905 : }
906 : }
907 0 : mType = (aOther).type();
908 : }
909 :
910 0 : OptionalThebesBuffer::~OptionalThebesBuffer()
911 : {
912 0 : MaybeDestroy(T__None);
913 0 : }
914 :
915 : OptionalThebesBuffer&
916 0 : OptionalThebesBuffer::operator=(const ThebesBuffer& aRhs)
917 : {
918 0 : if (MaybeDestroy(TThebesBuffer)) {
919 0 : new (ptr_ThebesBuffer()) ThebesBuffer;
920 : }
921 0 : (*(ptr_ThebesBuffer())) = aRhs;
922 0 : mType = TThebesBuffer;
923 0 : return (*(this));
924 : }
925 :
926 : OptionalThebesBuffer&
927 0 : OptionalThebesBuffer::operator=(const null_t& aRhs)
928 : {
929 0 : if (MaybeDestroy(Tnull_t)) {
930 0 : new (ptr_null_t()) null_t;
931 : }
932 0 : (*(ptr_null_t())) = aRhs;
933 0 : mType = Tnull_t;
934 0 : return (*(this));
935 : }
936 :
937 : OptionalThebesBuffer&
938 0 : OptionalThebesBuffer::operator=(const OptionalThebesBuffer& aRhs)
939 : {
940 0 : (aRhs).AssertSanity();
941 0 : Type t = (aRhs).type();
942 0 : switch (t) {
943 : case TThebesBuffer:
944 : {
945 0 : if (MaybeDestroy(t)) {
946 0 : new (ptr_ThebesBuffer()) ThebesBuffer;
947 : }
948 0 : (*(ptr_ThebesBuffer())) = (aRhs).get_ThebesBuffer();
949 0 : break;
950 : }
951 : case Tnull_t:
952 : {
953 0 : if (MaybeDestroy(t)) {
954 0 : new (ptr_null_t()) null_t;
955 : }
956 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
957 0 : break;
958 : }
959 : case T__None:
960 : {
961 0 : MaybeDestroy(t);
962 0 : break;
963 : }
964 : default:
965 : {
966 0 : NS_RUNTIMEABORT("unreached");
967 0 : break;
968 : }
969 : }
970 0 : mType = t;
971 0 : return (*(this));
972 : }
973 :
974 : bool
975 0 : OptionalThebesBuffer::operator==(const ThebesBuffer& aRhs) const
976 : {
977 0 : return (get_ThebesBuffer()) == (aRhs);
978 : }
979 :
980 : bool
981 0 : OptionalThebesBuffer::operator==(const null_t& aRhs) const
982 : {
983 0 : return (get_null_t()) == (aRhs);
984 : }
985 :
986 : bool
987 0 : OptionalThebesBuffer::operator==(const OptionalThebesBuffer& aRhs) const
988 : {
989 0 : if ((type()) != ((aRhs).type())) {
990 0 : return false;
991 : }
992 :
993 0 : switch (type()) {
994 : case TThebesBuffer:
995 : {
996 0 : return (get_ThebesBuffer()) == ((aRhs).get_ThebesBuffer());
997 : }
998 : case Tnull_t:
999 : {
1000 0 : return (get_null_t()) == ((aRhs).get_null_t());
1001 : }
1002 : default:
1003 : {
1004 0 : NS_RUNTIMEABORT("unreached");
1005 0 : return false;
1006 : }
1007 : }
1008 : }
1009 :
1010 : } // namespace layers
1011 : } // namespace mozilla
1012 :
1013 : //-----------------------------------------------------------------------------
1014 : // Method definitions for the IPDL type |union CanvasSurface|
1015 : //
1016 : namespace mozilla {
1017 : namespace layers {
1018 : bool
1019 0 : CanvasSurface::MaybeDestroy(Type aNewType)
1020 : {
1021 0 : if ((mType) == (T__None)) {
1022 0 : return true;
1023 : }
1024 0 : if ((mType) == (aNewType)) {
1025 0 : return false;
1026 : }
1027 0 : switch (mType) {
1028 : case TSurfaceDescriptor:
1029 : {
1030 0 : (ptr_SurfaceDescriptor())->~SurfaceDescriptor__tdef();
1031 0 : break;
1032 : }
1033 : case Tnull_t:
1034 : {
1035 0 : (ptr_null_t())->~null_t__tdef();
1036 0 : break;
1037 : }
1038 : default:
1039 : {
1040 0 : NS_RUNTIMEABORT("not reached");
1041 0 : break;
1042 : }
1043 : }
1044 0 : return true;
1045 : }
1046 :
1047 0 : CanvasSurface::CanvasSurface(const SurfaceDescriptor& aOther)
1048 : {
1049 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor(aOther);
1050 0 : mType = TSurfaceDescriptor;
1051 0 : }
1052 :
1053 0 : CanvasSurface::CanvasSurface(const null_t& aOther)
1054 : {
1055 0 : new (ptr_null_t()) null_t(aOther);
1056 0 : mType = Tnull_t;
1057 0 : }
1058 :
1059 0 : CanvasSurface::CanvasSurface(const CanvasSurface& aOther)
1060 : {
1061 0 : (aOther).AssertSanity();
1062 0 : switch ((aOther).type()) {
1063 : case TSurfaceDescriptor:
1064 : {
1065 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor((aOther).get_SurfaceDescriptor());
1066 0 : break;
1067 : }
1068 : case Tnull_t:
1069 : {
1070 0 : new (ptr_null_t()) null_t((aOther).get_null_t());
1071 0 : break;
1072 : }
1073 : case T__None:
1074 : {
1075 0 : break;
1076 : }
1077 : default:
1078 : {
1079 0 : NS_RUNTIMEABORT("unreached");
1080 0 : return;
1081 : }
1082 : }
1083 0 : mType = (aOther).type();
1084 : }
1085 :
1086 0 : CanvasSurface::~CanvasSurface()
1087 : {
1088 0 : MaybeDestroy(T__None);
1089 0 : }
1090 :
1091 : CanvasSurface&
1092 0 : CanvasSurface::operator=(const SurfaceDescriptor& aRhs)
1093 : {
1094 0 : if (MaybeDestroy(TSurfaceDescriptor)) {
1095 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor;
1096 : }
1097 0 : (*(ptr_SurfaceDescriptor())) = aRhs;
1098 0 : mType = TSurfaceDescriptor;
1099 0 : return (*(this));
1100 : }
1101 :
1102 : CanvasSurface&
1103 0 : CanvasSurface::operator=(const null_t& aRhs)
1104 : {
1105 0 : if (MaybeDestroy(Tnull_t)) {
1106 0 : new (ptr_null_t()) null_t;
1107 : }
1108 0 : (*(ptr_null_t())) = aRhs;
1109 0 : mType = Tnull_t;
1110 0 : return (*(this));
1111 : }
1112 :
1113 : CanvasSurface&
1114 0 : CanvasSurface::operator=(const CanvasSurface& aRhs)
1115 : {
1116 0 : (aRhs).AssertSanity();
1117 0 : Type t = (aRhs).type();
1118 0 : switch (t) {
1119 : case TSurfaceDescriptor:
1120 : {
1121 0 : if (MaybeDestroy(t)) {
1122 0 : new (ptr_SurfaceDescriptor()) SurfaceDescriptor;
1123 : }
1124 0 : (*(ptr_SurfaceDescriptor())) = (aRhs).get_SurfaceDescriptor();
1125 0 : break;
1126 : }
1127 : case Tnull_t:
1128 : {
1129 0 : if (MaybeDestroy(t)) {
1130 0 : new (ptr_null_t()) null_t;
1131 : }
1132 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
1133 0 : break;
1134 : }
1135 : case T__None:
1136 : {
1137 0 : MaybeDestroy(t);
1138 0 : break;
1139 : }
1140 : default:
1141 : {
1142 0 : NS_RUNTIMEABORT("unreached");
1143 0 : break;
1144 : }
1145 : }
1146 0 : mType = t;
1147 0 : return (*(this));
1148 : }
1149 :
1150 : bool
1151 0 : CanvasSurface::operator==(const SurfaceDescriptor& aRhs) const
1152 : {
1153 0 : return (get_SurfaceDescriptor()) == (aRhs);
1154 : }
1155 :
1156 : bool
1157 0 : CanvasSurface::operator==(const null_t& aRhs) const
1158 : {
1159 0 : return (get_null_t()) == (aRhs);
1160 : }
1161 :
1162 : bool
1163 0 : CanvasSurface::operator==(const CanvasSurface& aRhs) const
1164 : {
1165 0 : if ((type()) != ((aRhs).type())) {
1166 0 : return false;
1167 : }
1168 :
1169 0 : switch (type()) {
1170 : case TSurfaceDescriptor:
1171 : {
1172 0 : return (get_SurfaceDescriptor()) == ((aRhs).get_SurfaceDescriptor());
1173 : }
1174 : case Tnull_t:
1175 : {
1176 0 : return (get_null_t()) == ((aRhs).get_null_t());
1177 : }
1178 : default:
1179 : {
1180 0 : NS_RUNTIMEABORT("unreached");
1181 0 : return false;
1182 : }
1183 : }
1184 : }
1185 :
1186 : } // namespace layers
1187 : } // namespace mozilla
1188 :
1189 : //-----------------------------------------------------------------------------
1190 : // Method definitions for the IPDL type |struct CommonLayerAttributes|
1191 : //
1192 : namespace mozilla {
1193 : namespace layers {
1194 0 : CommonLayerAttributes::CommonLayerAttributes()
1195 : {
1196 0 : Init();
1197 0 : }
1198 :
1199 0 : CommonLayerAttributes::~CommonLayerAttributes()
1200 : {
1201 0 : }
1202 :
1203 : bool
1204 0 : CommonLayerAttributes::operator==(const CommonLayerAttributes& _o) const
1205 : {
1206 0 : if ((!((visibleRegion()) == ((_o).visibleRegion())))) {
1207 0 : return false;
1208 : }
1209 0 : if ((!((transform()) == ((_o).transform())))) {
1210 0 : return false;
1211 : }
1212 0 : if ((!((contentFlags()) == ((_o).contentFlags())))) {
1213 0 : return false;
1214 : }
1215 0 : if ((!((opacity()) == ((_o).opacity())))) {
1216 0 : return false;
1217 : }
1218 0 : if ((!((useClipRect()) == ((_o).useClipRect())))) {
1219 0 : return false;
1220 : }
1221 0 : if ((!((clipRect()) == ((_o).clipRect())))) {
1222 0 : return false;
1223 : }
1224 0 : if ((!((useTileSourceRect()) == ((_o).useTileSourceRect())))) {
1225 0 : return false;
1226 : }
1227 0 : if ((!((tileSourceRect()) == ((_o).tileSourceRect())))) {
1228 0 : return false;
1229 : }
1230 0 : if ((!((isFixedPosition()) == ((_o).isFixedPosition())))) {
1231 0 : return false;
1232 : }
1233 0 : return true;
1234 : }
1235 :
1236 : void
1237 0 : CommonLayerAttributes::Init()
1238 : {
1239 0 : }
1240 :
1241 : void
1242 0 : CommonLayerAttributes::Assign(
1243 : const nsIntRegion& _visibleRegion,
1244 : const gfx3DMatrix& _transform,
1245 : const PRUint32& _contentFlags,
1246 : const float& _opacity,
1247 : const bool& _useClipRect,
1248 : const nsIntRect& _clipRect,
1249 : const bool& _useTileSourceRect,
1250 : const nsIntRect& _tileSourceRect,
1251 : const bool& _isFixedPosition)
1252 : {
1253 0 : visibleRegion_ = _visibleRegion;
1254 0 : transform_ = _transform;
1255 0 : contentFlags_ = _contentFlags;
1256 0 : opacity_ = _opacity;
1257 0 : useClipRect_ = _useClipRect;
1258 0 : clipRect_ = _clipRect;
1259 0 : useTileSourceRect_ = _useTileSourceRect;
1260 0 : tileSourceRect_ = _tileSourceRect;
1261 0 : isFixedPosition_ = _isFixedPosition;
1262 0 : }
1263 :
1264 : } // namespace layers
1265 : } // namespace mozilla
1266 :
1267 : //-----------------------------------------------------------------------------
1268 : // Method definitions for the IPDL type |struct ThebesLayerAttributes|
1269 : //
1270 : namespace mozilla {
1271 : namespace layers {
1272 0 : ThebesLayerAttributes::ThebesLayerAttributes()
1273 : {
1274 0 : Init();
1275 0 : }
1276 :
1277 0 : ThebesLayerAttributes::~ThebesLayerAttributes()
1278 : {
1279 0 : }
1280 :
1281 : bool
1282 0 : ThebesLayerAttributes::operator==(const ThebesLayerAttributes& _o) const
1283 : {
1284 0 : if ((!((validRegion()) == ((_o).validRegion())))) {
1285 0 : return false;
1286 : }
1287 0 : return true;
1288 : }
1289 :
1290 : void
1291 0 : ThebesLayerAttributes::Init()
1292 : {
1293 0 : }
1294 :
1295 : void
1296 0 : ThebesLayerAttributes::Assign(const nsIntRegion& _validRegion)
1297 : {
1298 0 : validRegion_ = _validRegion;
1299 0 : }
1300 :
1301 : } // namespace layers
1302 : } // namespace mozilla
1303 :
1304 : //-----------------------------------------------------------------------------
1305 : // Method definitions for the IPDL type |struct ContainerLayerAttributes|
1306 : //
1307 : namespace mozilla {
1308 : namespace layers {
1309 0 : ContainerLayerAttributes::ContainerLayerAttributes()
1310 : {
1311 0 : Init();
1312 0 : }
1313 :
1314 0 : ContainerLayerAttributes::~ContainerLayerAttributes()
1315 : {
1316 0 : }
1317 :
1318 : bool
1319 0 : ContainerLayerAttributes::operator==(const ContainerLayerAttributes& _o) const
1320 : {
1321 0 : if ((!((metrics()) == ((_o).metrics())))) {
1322 0 : return false;
1323 : }
1324 0 : return true;
1325 : }
1326 :
1327 : void
1328 0 : ContainerLayerAttributes::Init()
1329 : {
1330 0 : }
1331 :
1332 : void
1333 0 : ContainerLayerAttributes::Assign(const FrameMetrics& _metrics)
1334 : {
1335 0 : metrics_ = _metrics;
1336 0 : }
1337 :
1338 : } // namespace layers
1339 : } // namespace mozilla
1340 :
1341 : //-----------------------------------------------------------------------------
1342 : // Method definitions for the IPDL type |struct ColorLayerAttributes|
1343 : //
1344 : namespace mozilla {
1345 : namespace layers {
1346 0 : ColorLayerAttributes::ColorLayerAttributes()
1347 : {
1348 0 : Init();
1349 0 : }
1350 :
1351 0 : ColorLayerAttributes::~ColorLayerAttributes()
1352 : {
1353 0 : }
1354 :
1355 : bool
1356 0 : ColorLayerAttributes::operator==(const ColorLayerAttributes& _o) const
1357 : {
1358 0 : if ((!((color()) == ((_o).color())))) {
1359 0 : return false;
1360 : }
1361 0 : return true;
1362 : }
1363 :
1364 : void
1365 0 : ColorLayerAttributes::Init()
1366 : {
1367 0 : }
1368 :
1369 : void
1370 0 : ColorLayerAttributes::Assign(const gfxRGBA& _color)
1371 : {
1372 0 : color_ = _color;
1373 0 : }
1374 :
1375 : } // namespace layers
1376 : } // namespace mozilla
1377 :
1378 : //-----------------------------------------------------------------------------
1379 : // Method definitions for the IPDL type |struct CanvasLayerAttributes|
1380 : //
1381 : namespace mozilla {
1382 : namespace layers {
1383 0 : CanvasLayerAttributes::CanvasLayerAttributes()
1384 : {
1385 0 : Init();
1386 0 : }
1387 :
1388 0 : CanvasLayerAttributes::~CanvasLayerAttributes()
1389 : {
1390 0 : }
1391 :
1392 : bool
1393 0 : CanvasLayerAttributes::operator==(const CanvasLayerAttributes& _o) const
1394 : {
1395 0 : if ((!((filter()) == ((_o).filter())))) {
1396 0 : return false;
1397 : }
1398 0 : return true;
1399 : }
1400 :
1401 : void
1402 0 : CanvasLayerAttributes::Init()
1403 : {
1404 0 : }
1405 :
1406 : void
1407 0 : CanvasLayerAttributes::Assign(const GraphicsFilterType& _filter)
1408 : {
1409 0 : filter_ = _filter;
1410 0 : }
1411 :
1412 : } // namespace layers
1413 : } // namespace mozilla
1414 :
1415 : //-----------------------------------------------------------------------------
1416 : // Method definitions for the IPDL type |struct ImageLayerAttributes|
1417 : //
1418 : namespace mozilla {
1419 : namespace layers {
1420 0 : ImageLayerAttributes::ImageLayerAttributes()
1421 : {
1422 0 : Init();
1423 0 : }
1424 :
1425 0 : ImageLayerAttributes::~ImageLayerAttributes()
1426 : {
1427 0 : }
1428 :
1429 : bool
1430 0 : ImageLayerAttributes::operator==(const ImageLayerAttributes& _o) const
1431 : {
1432 0 : if ((!((filter()) == ((_o).filter())))) {
1433 0 : return false;
1434 : }
1435 0 : return true;
1436 : }
1437 :
1438 : void
1439 0 : ImageLayerAttributes::Init()
1440 : {
1441 0 : }
1442 :
1443 : void
1444 0 : ImageLayerAttributes::Assign(const GraphicsFilterType& _filter)
1445 : {
1446 0 : filter_ = _filter;
1447 0 : }
1448 :
1449 : } // namespace layers
1450 : } // namespace mozilla
1451 :
1452 : //-----------------------------------------------------------------------------
1453 : // Method definitions for the IPDL type |union SpecificLayerAttributes|
1454 : //
1455 : namespace mozilla {
1456 : namespace layers {
1457 : bool
1458 0 : SpecificLayerAttributes::MaybeDestroy(Type aNewType)
1459 : {
1460 0 : if ((mType) == (T__None)) {
1461 0 : return true;
1462 : }
1463 0 : if ((mType) == (aNewType)) {
1464 0 : return false;
1465 : }
1466 0 : switch (mType) {
1467 : case Tnull_t:
1468 : {
1469 0 : (ptr_null_t())->~null_t__tdef();
1470 0 : break;
1471 : }
1472 : case TThebesLayerAttributes:
1473 : {
1474 0 : (ptr_ThebesLayerAttributes())->~ThebesLayerAttributes__tdef();
1475 0 : break;
1476 : }
1477 : case TContainerLayerAttributes:
1478 : {
1479 0 : (ptr_ContainerLayerAttributes())->~ContainerLayerAttributes__tdef();
1480 0 : break;
1481 : }
1482 : case TColorLayerAttributes:
1483 : {
1484 0 : (ptr_ColorLayerAttributes())->~ColorLayerAttributes__tdef();
1485 0 : break;
1486 : }
1487 : case TCanvasLayerAttributes:
1488 : {
1489 0 : (ptr_CanvasLayerAttributes())->~CanvasLayerAttributes__tdef();
1490 0 : break;
1491 : }
1492 : case TImageLayerAttributes:
1493 : {
1494 0 : (ptr_ImageLayerAttributes())->~ImageLayerAttributes__tdef();
1495 0 : break;
1496 : }
1497 : default:
1498 : {
1499 0 : NS_RUNTIMEABORT("not reached");
1500 0 : break;
1501 : }
1502 : }
1503 0 : return true;
1504 : }
1505 :
1506 0 : SpecificLayerAttributes::SpecificLayerAttributes(const null_t& aOther)
1507 : {
1508 0 : new (ptr_null_t()) null_t(aOther);
1509 0 : mType = Tnull_t;
1510 0 : }
1511 :
1512 0 : SpecificLayerAttributes::SpecificLayerAttributes(const ThebesLayerAttributes& aOther)
1513 : {
1514 0 : new (ptr_ThebesLayerAttributes()) ThebesLayerAttributes(aOther);
1515 0 : mType = TThebesLayerAttributes;
1516 0 : }
1517 :
1518 0 : SpecificLayerAttributes::SpecificLayerAttributes(const ContainerLayerAttributes& aOther)
1519 : {
1520 0 : new (ptr_ContainerLayerAttributes()) ContainerLayerAttributes(aOther);
1521 0 : mType = TContainerLayerAttributes;
1522 0 : }
1523 :
1524 0 : SpecificLayerAttributes::SpecificLayerAttributes(const ColorLayerAttributes& aOther)
1525 : {
1526 0 : new (ptr_ColorLayerAttributes()) ColorLayerAttributes(aOther);
1527 0 : mType = TColorLayerAttributes;
1528 0 : }
1529 :
1530 0 : SpecificLayerAttributes::SpecificLayerAttributes(const CanvasLayerAttributes& aOther)
1531 : {
1532 0 : new (ptr_CanvasLayerAttributes()) CanvasLayerAttributes(aOther);
1533 0 : mType = TCanvasLayerAttributes;
1534 0 : }
1535 :
1536 0 : SpecificLayerAttributes::SpecificLayerAttributes(const ImageLayerAttributes& aOther)
1537 : {
1538 0 : new (ptr_ImageLayerAttributes()) ImageLayerAttributes(aOther);
1539 0 : mType = TImageLayerAttributes;
1540 0 : }
1541 :
1542 0 : SpecificLayerAttributes::SpecificLayerAttributes(const SpecificLayerAttributes& aOther)
1543 : {
1544 0 : (aOther).AssertSanity();
1545 0 : switch ((aOther).type()) {
1546 : case Tnull_t:
1547 : {
1548 0 : new (ptr_null_t()) null_t((aOther).get_null_t());
1549 0 : break;
1550 : }
1551 : case TThebesLayerAttributes:
1552 : {
1553 0 : new (ptr_ThebesLayerAttributes()) ThebesLayerAttributes((aOther).get_ThebesLayerAttributes());
1554 0 : break;
1555 : }
1556 : case TContainerLayerAttributes:
1557 : {
1558 0 : new (ptr_ContainerLayerAttributes()) ContainerLayerAttributes((aOther).get_ContainerLayerAttributes());
1559 0 : break;
1560 : }
1561 : case TColorLayerAttributes:
1562 : {
1563 0 : new (ptr_ColorLayerAttributes()) ColorLayerAttributes((aOther).get_ColorLayerAttributes());
1564 0 : break;
1565 : }
1566 : case TCanvasLayerAttributes:
1567 : {
1568 0 : new (ptr_CanvasLayerAttributes()) CanvasLayerAttributes((aOther).get_CanvasLayerAttributes());
1569 0 : break;
1570 : }
1571 : case TImageLayerAttributes:
1572 : {
1573 0 : new (ptr_ImageLayerAttributes()) ImageLayerAttributes((aOther).get_ImageLayerAttributes());
1574 0 : break;
1575 : }
1576 : case T__None:
1577 : {
1578 0 : break;
1579 : }
1580 : default:
1581 : {
1582 0 : NS_RUNTIMEABORT("unreached");
1583 0 : return;
1584 : }
1585 : }
1586 0 : mType = (aOther).type();
1587 : }
1588 :
1589 0 : SpecificLayerAttributes::~SpecificLayerAttributes()
1590 : {
1591 0 : MaybeDestroy(T__None);
1592 0 : }
1593 :
1594 : SpecificLayerAttributes&
1595 0 : SpecificLayerAttributes::operator=(const null_t& aRhs)
1596 : {
1597 0 : if (MaybeDestroy(Tnull_t)) {
1598 0 : new (ptr_null_t()) null_t;
1599 : }
1600 0 : (*(ptr_null_t())) = aRhs;
1601 0 : mType = Tnull_t;
1602 0 : return (*(this));
1603 : }
1604 :
1605 : SpecificLayerAttributes&
1606 0 : SpecificLayerAttributes::operator=(const ThebesLayerAttributes& aRhs)
1607 : {
1608 0 : if (MaybeDestroy(TThebesLayerAttributes)) {
1609 0 : new (ptr_ThebesLayerAttributes()) ThebesLayerAttributes;
1610 : }
1611 0 : (*(ptr_ThebesLayerAttributes())) = aRhs;
1612 0 : mType = TThebesLayerAttributes;
1613 0 : return (*(this));
1614 : }
1615 :
1616 : SpecificLayerAttributes&
1617 0 : SpecificLayerAttributes::operator=(const ContainerLayerAttributes& aRhs)
1618 : {
1619 0 : if (MaybeDestroy(TContainerLayerAttributes)) {
1620 0 : new (ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
1621 : }
1622 0 : (*(ptr_ContainerLayerAttributes())) = aRhs;
1623 0 : mType = TContainerLayerAttributes;
1624 0 : return (*(this));
1625 : }
1626 :
1627 : SpecificLayerAttributes&
1628 0 : SpecificLayerAttributes::operator=(const ColorLayerAttributes& aRhs)
1629 : {
1630 0 : if (MaybeDestroy(TColorLayerAttributes)) {
1631 0 : new (ptr_ColorLayerAttributes()) ColorLayerAttributes;
1632 : }
1633 0 : (*(ptr_ColorLayerAttributes())) = aRhs;
1634 0 : mType = TColorLayerAttributes;
1635 0 : return (*(this));
1636 : }
1637 :
1638 : SpecificLayerAttributes&
1639 0 : SpecificLayerAttributes::operator=(const CanvasLayerAttributes& aRhs)
1640 : {
1641 0 : if (MaybeDestroy(TCanvasLayerAttributes)) {
1642 0 : new (ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
1643 : }
1644 0 : (*(ptr_CanvasLayerAttributes())) = aRhs;
1645 0 : mType = TCanvasLayerAttributes;
1646 0 : return (*(this));
1647 : }
1648 :
1649 : SpecificLayerAttributes&
1650 0 : SpecificLayerAttributes::operator=(const ImageLayerAttributes& aRhs)
1651 : {
1652 0 : if (MaybeDestroy(TImageLayerAttributes)) {
1653 0 : new (ptr_ImageLayerAttributes()) ImageLayerAttributes;
1654 : }
1655 0 : (*(ptr_ImageLayerAttributes())) = aRhs;
1656 0 : mType = TImageLayerAttributes;
1657 0 : return (*(this));
1658 : }
1659 :
1660 : SpecificLayerAttributes&
1661 0 : SpecificLayerAttributes::operator=(const SpecificLayerAttributes& aRhs)
1662 : {
1663 0 : (aRhs).AssertSanity();
1664 0 : Type t = (aRhs).type();
1665 0 : switch (t) {
1666 : case Tnull_t:
1667 : {
1668 0 : if (MaybeDestroy(t)) {
1669 0 : new (ptr_null_t()) null_t;
1670 : }
1671 0 : (*(ptr_null_t())) = (aRhs).get_null_t();
1672 0 : break;
1673 : }
1674 : case TThebesLayerAttributes:
1675 : {
1676 0 : if (MaybeDestroy(t)) {
1677 0 : new (ptr_ThebesLayerAttributes()) ThebesLayerAttributes;
1678 : }
1679 0 : (*(ptr_ThebesLayerAttributes())) = (aRhs).get_ThebesLayerAttributes();
1680 0 : break;
1681 : }
1682 : case TContainerLayerAttributes:
1683 : {
1684 0 : if (MaybeDestroy(t)) {
1685 0 : new (ptr_ContainerLayerAttributes()) ContainerLayerAttributes;
1686 : }
1687 0 : (*(ptr_ContainerLayerAttributes())) = (aRhs).get_ContainerLayerAttributes();
1688 0 : break;
1689 : }
1690 : case TColorLayerAttributes:
1691 : {
1692 0 : if (MaybeDestroy(t)) {
1693 0 : new (ptr_ColorLayerAttributes()) ColorLayerAttributes;
1694 : }
1695 0 : (*(ptr_ColorLayerAttributes())) = (aRhs).get_ColorLayerAttributes();
1696 0 : break;
1697 : }
1698 : case TCanvasLayerAttributes:
1699 : {
1700 0 : if (MaybeDestroy(t)) {
1701 0 : new (ptr_CanvasLayerAttributes()) CanvasLayerAttributes;
1702 : }
1703 0 : (*(ptr_CanvasLayerAttributes())) = (aRhs).get_CanvasLayerAttributes();
1704 0 : break;
1705 : }
1706 : case TImageLayerAttributes:
1707 : {
1708 0 : if (MaybeDestroy(t)) {
1709 0 : new (ptr_ImageLayerAttributes()) ImageLayerAttributes;
1710 : }
1711 0 : (*(ptr_ImageLayerAttributes())) = (aRhs).get_ImageLayerAttributes();
1712 0 : break;
1713 : }
1714 : case T__None:
1715 : {
1716 0 : MaybeDestroy(t);
1717 0 : break;
1718 : }
1719 : default:
1720 : {
1721 0 : NS_RUNTIMEABORT("unreached");
1722 0 : break;
1723 : }
1724 : }
1725 0 : mType = t;
1726 0 : return (*(this));
1727 : }
1728 :
1729 : bool
1730 0 : SpecificLayerAttributes::operator==(const null_t& aRhs) const
1731 : {
1732 0 : return (get_null_t()) == (aRhs);
1733 : }
1734 :
1735 : bool
1736 0 : SpecificLayerAttributes::operator==(const ThebesLayerAttributes& aRhs) const
1737 : {
1738 0 : return (get_ThebesLayerAttributes()) == (aRhs);
1739 : }
1740 :
1741 : bool
1742 0 : SpecificLayerAttributes::operator==(const ContainerLayerAttributes& aRhs) const
1743 : {
1744 0 : return (get_ContainerLayerAttributes()) == (aRhs);
1745 : }
1746 :
1747 : bool
1748 0 : SpecificLayerAttributes::operator==(const ColorLayerAttributes& aRhs) const
1749 : {
1750 0 : return (get_ColorLayerAttributes()) == (aRhs);
1751 : }
1752 :
1753 : bool
1754 0 : SpecificLayerAttributes::operator==(const CanvasLayerAttributes& aRhs) const
1755 : {
1756 0 : return (get_CanvasLayerAttributes()) == (aRhs);
1757 : }
1758 :
1759 : bool
1760 0 : SpecificLayerAttributes::operator==(const ImageLayerAttributes& aRhs) const
1761 : {
1762 0 : return (get_ImageLayerAttributes()) == (aRhs);
1763 : }
1764 :
1765 : bool
1766 0 : SpecificLayerAttributes::operator==(const SpecificLayerAttributes& aRhs) const
1767 : {
1768 0 : if ((type()) != ((aRhs).type())) {
1769 0 : return false;
1770 : }
1771 :
1772 0 : switch (type()) {
1773 : case Tnull_t:
1774 : {
1775 0 : return (get_null_t()) == ((aRhs).get_null_t());
1776 : }
1777 : case TThebesLayerAttributes:
1778 : {
1779 0 : return (get_ThebesLayerAttributes()) == ((aRhs).get_ThebesLayerAttributes());
1780 : }
1781 : case TContainerLayerAttributes:
1782 : {
1783 0 : return (get_ContainerLayerAttributes()) == ((aRhs).get_ContainerLayerAttributes());
1784 : }
1785 : case TColorLayerAttributes:
1786 : {
1787 0 : return (get_ColorLayerAttributes()) == ((aRhs).get_ColorLayerAttributes());
1788 : }
1789 : case TCanvasLayerAttributes:
1790 : {
1791 0 : return (get_CanvasLayerAttributes()) == ((aRhs).get_CanvasLayerAttributes());
1792 : }
1793 : case TImageLayerAttributes:
1794 : {
1795 0 : return (get_ImageLayerAttributes()) == ((aRhs).get_ImageLayerAttributes());
1796 : }
1797 : default:
1798 : {
1799 0 : NS_RUNTIMEABORT("unreached");
1800 0 : return false;
1801 : }
1802 : }
1803 : }
1804 :
1805 : } // namespace layers
1806 : } // namespace mozilla
1807 :
1808 : //-----------------------------------------------------------------------------
1809 : // Method definitions for the IPDL type |struct LayerAttributes|
1810 : //
1811 : namespace mozilla {
1812 : namespace layers {
1813 0 : LayerAttributes::LayerAttributes()
1814 : {
1815 0 : Init();
1816 0 : }
1817 :
1818 0 : LayerAttributes::~LayerAttributes()
1819 : {
1820 0 : }
1821 :
1822 : bool
1823 0 : LayerAttributes::operator==(const LayerAttributes& _o) const
1824 : {
1825 0 : if ((!((common()) == ((_o).common())))) {
1826 0 : return false;
1827 : }
1828 0 : if ((!((specific()) == ((_o).specific())))) {
1829 0 : return false;
1830 : }
1831 0 : return true;
1832 : }
1833 :
1834 : void
1835 0 : LayerAttributes::Init()
1836 : {
1837 0 : }
1838 :
1839 : void
1840 0 : LayerAttributes::Assign(
1841 : const CommonLayerAttributes& _common,
1842 : const SpecificLayerAttributes& _specific)
1843 : {
1844 0 : common_ = _common;
1845 0 : specific_ = _specific;
1846 0 : }
1847 :
1848 : } // namespace layers
1849 : } // namespace mozilla
1850 :
1851 : //-----------------------------------------------------------------------------
1852 : // Method definitions for the IPDL type |struct OpSetLayerAttributes|
1853 : //
1854 : namespace mozilla {
1855 : namespace layers {
1856 0 : OpSetLayerAttributes::OpSetLayerAttributes()
1857 : {
1858 0 : Init();
1859 0 : }
1860 :
1861 0 : OpSetLayerAttributes::~OpSetLayerAttributes()
1862 : {
1863 0 : }
1864 :
1865 : bool
1866 0 : OpSetLayerAttributes::operator==(const OpSetLayerAttributes& _o) const
1867 : {
1868 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
1869 0 : return false;
1870 : }
1871 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
1872 0 : return false;
1873 : }
1874 0 : if ((!((attrs()) == ((_o).attrs())))) {
1875 0 : return false;
1876 : }
1877 0 : return true;
1878 : }
1879 :
1880 : void
1881 0 : OpSetLayerAttributes::Init()
1882 : {
1883 0 : }
1884 :
1885 : void
1886 0 : OpSetLayerAttributes::Assign(
1887 : PLayerParent* _layerParent,
1888 : PLayerChild* _layerChild,
1889 : const LayerAttributes& _attrs)
1890 : {
1891 0 : layerParent_ = _layerParent;
1892 0 : layerChild_ = _layerChild;
1893 0 : attrs_ = _attrs;
1894 0 : }
1895 :
1896 : } // namespace layers
1897 : } // namespace mozilla
1898 :
1899 : //-----------------------------------------------------------------------------
1900 : // Method definitions for the IPDL type |struct OpSetRoot|
1901 : //
1902 : namespace mozilla {
1903 : namespace layers {
1904 0 : OpSetRoot::OpSetRoot()
1905 : {
1906 0 : Init();
1907 0 : }
1908 :
1909 0 : OpSetRoot::~OpSetRoot()
1910 : {
1911 0 : }
1912 :
1913 : bool
1914 0 : OpSetRoot::operator==(const OpSetRoot& _o) const
1915 : {
1916 0 : if ((!((rootParent()) == ((_o).rootParent())))) {
1917 0 : return false;
1918 : }
1919 0 : if ((!((rootChild()) == ((_o).rootChild())))) {
1920 0 : return false;
1921 : }
1922 0 : return true;
1923 : }
1924 :
1925 : void
1926 0 : OpSetRoot::Init()
1927 : {
1928 0 : }
1929 :
1930 : void
1931 0 : OpSetRoot::Assign(
1932 : PLayerParent* _rootParent,
1933 : PLayerChild* _rootChild)
1934 : {
1935 0 : rootParent_ = _rootParent;
1936 0 : rootChild_ = _rootChild;
1937 0 : }
1938 :
1939 : } // namespace layers
1940 : } // namespace mozilla
1941 :
1942 : //-----------------------------------------------------------------------------
1943 : // Method definitions for the IPDL type |struct OpInsertAfter|
1944 : //
1945 : namespace mozilla {
1946 : namespace layers {
1947 0 : OpInsertAfter::OpInsertAfter()
1948 : {
1949 0 : Init();
1950 0 : }
1951 :
1952 0 : OpInsertAfter::~OpInsertAfter()
1953 : {
1954 0 : }
1955 :
1956 : bool
1957 0 : OpInsertAfter::operator==(const OpInsertAfter& _o) const
1958 : {
1959 0 : if ((!((containerParent()) == ((_o).containerParent())))) {
1960 0 : return false;
1961 : }
1962 0 : if ((!((containerChild()) == ((_o).containerChild())))) {
1963 0 : return false;
1964 : }
1965 0 : if ((!((childLayerParent()) == ((_o).childLayerParent())))) {
1966 0 : return false;
1967 : }
1968 0 : if ((!((childLayerChild()) == ((_o).childLayerChild())))) {
1969 0 : return false;
1970 : }
1971 0 : if ((!((afterParent()) == ((_o).afterParent())))) {
1972 0 : return false;
1973 : }
1974 0 : if ((!((afterChild()) == ((_o).afterChild())))) {
1975 0 : return false;
1976 : }
1977 0 : return true;
1978 : }
1979 :
1980 : void
1981 0 : OpInsertAfter::Init()
1982 : {
1983 0 : }
1984 :
1985 : void
1986 0 : OpInsertAfter::Assign(
1987 : PLayerParent* _containerParent,
1988 : PLayerChild* _containerChild,
1989 : PLayerParent* _childLayerParent,
1990 : PLayerChild* _childLayerChild,
1991 : PLayerParent* _afterParent,
1992 : PLayerChild* _afterChild)
1993 : {
1994 0 : containerParent_ = _containerParent;
1995 0 : containerChild_ = _containerChild;
1996 0 : childLayerParent_ = _childLayerParent;
1997 0 : childLayerChild_ = _childLayerChild;
1998 0 : afterParent_ = _afterParent;
1999 0 : afterChild_ = _afterChild;
2000 0 : }
2001 :
2002 : } // namespace layers
2003 : } // namespace mozilla
2004 :
2005 : //-----------------------------------------------------------------------------
2006 : // Method definitions for the IPDL type |struct OpAppendChild|
2007 : //
2008 : namespace mozilla {
2009 : namespace layers {
2010 0 : OpAppendChild::OpAppendChild()
2011 : {
2012 0 : Init();
2013 0 : }
2014 :
2015 0 : OpAppendChild::~OpAppendChild()
2016 : {
2017 0 : }
2018 :
2019 : bool
2020 0 : OpAppendChild::operator==(const OpAppendChild& _o) const
2021 : {
2022 0 : if ((!((containerParent()) == ((_o).containerParent())))) {
2023 0 : return false;
2024 : }
2025 0 : if ((!((containerChild()) == ((_o).containerChild())))) {
2026 0 : return false;
2027 : }
2028 0 : if ((!((childLayerParent()) == ((_o).childLayerParent())))) {
2029 0 : return false;
2030 : }
2031 0 : if ((!((childLayerChild()) == ((_o).childLayerChild())))) {
2032 0 : return false;
2033 : }
2034 0 : return true;
2035 : }
2036 :
2037 : void
2038 0 : OpAppendChild::Init()
2039 : {
2040 0 : }
2041 :
2042 : void
2043 0 : OpAppendChild::Assign(
2044 : PLayerParent* _containerParent,
2045 : PLayerChild* _containerChild,
2046 : PLayerParent* _childLayerParent,
2047 : PLayerChild* _childLayerChild)
2048 : {
2049 0 : containerParent_ = _containerParent;
2050 0 : containerChild_ = _containerChild;
2051 0 : childLayerParent_ = _childLayerParent;
2052 0 : childLayerChild_ = _childLayerChild;
2053 0 : }
2054 :
2055 : } // namespace layers
2056 : } // namespace mozilla
2057 :
2058 : //-----------------------------------------------------------------------------
2059 : // Method definitions for the IPDL type |struct OpRemoveChild|
2060 : //
2061 : namespace mozilla {
2062 : namespace layers {
2063 0 : OpRemoveChild::OpRemoveChild()
2064 : {
2065 0 : Init();
2066 0 : }
2067 :
2068 0 : OpRemoveChild::~OpRemoveChild()
2069 : {
2070 0 : }
2071 :
2072 : bool
2073 0 : OpRemoveChild::operator==(const OpRemoveChild& _o) const
2074 : {
2075 0 : if ((!((containerParent()) == ((_o).containerParent())))) {
2076 0 : return false;
2077 : }
2078 0 : if ((!((containerChild()) == ((_o).containerChild())))) {
2079 0 : return false;
2080 : }
2081 0 : if ((!((childLayerParent()) == ((_o).childLayerParent())))) {
2082 0 : return false;
2083 : }
2084 0 : if ((!((childLayerChild()) == ((_o).childLayerChild())))) {
2085 0 : return false;
2086 : }
2087 0 : return true;
2088 : }
2089 :
2090 : void
2091 0 : OpRemoveChild::Init()
2092 : {
2093 0 : }
2094 :
2095 : void
2096 0 : OpRemoveChild::Assign(
2097 : PLayerParent* _containerParent,
2098 : PLayerChild* _containerChild,
2099 : PLayerParent* _childLayerParent,
2100 : PLayerChild* _childLayerChild)
2101 : {
2102 0 : containerParent_ = _containerParent;
2103 0 : containerChild_ = _containerChild;
2104 0 : childLayerParent_ = _childLayerParent;
2105 0 : childLayerChild_ = _childLayerChild;
2106 0 : }
2107 :
2108 : } // namespace layers
2109 : } // namespace mozilla
2110 :
2111 : //-----------------------------------------------------------------------------
2112 : // Method definitions for the IPDL type |struct OpPaintThebesBuffer|
2113 : //
2114 : namespace mozilla {
2115 : namespace layers {
2116 0 : OpPaintThebesBuffer::OpPaintThebesBuffer()
2117 : {
2118 0 : Init();
2119 0 : }
2120 :
2121 0 : OpPaintThebesBuffer::~OpPaintThebesBuffer()
2122 : {
2123 0 : }
2124 :
2125 : bool
2126 0 : OpPaintThebesBuffer::operator==(const OpPaintThebesBuffer& _o) const
2127 : {
2128 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
2129 0 : return false;
2130 : }
2131 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
2132 0 : return false;
2133 : }
2134 0 : if ((!((newFrontBuffer()) == ((_o).newFrontBuffer())))) {
2135 0 : return false;
2136 : }
2137 0 : if ((!((updatedRegion()) == ((_o).updatedRegion())))) {
2138 0 : return false;
2139 : }
2140 0 : return true;
2141 : }
2142 :
2143 : void
2144 0 : OpPaintThebesBuffer::Init()
2145 : {
2146 0 : }
2147 :
2148 : void
2149 0 : OpPaintThebesBuffer::Assign(
2150 : PLayerParent* _layerParent,
2151 : PLayerChild* _layerChild,
2152 : const ThebesBuffer& _newFrontBuffer,
2153 : const nsIntRegion& _updatedRegion)
2154 : {
2155 0 : layerParent_ = _layerParent;
2156 0 : layerChild_ = _layerChild;
2157 0 : newFrontBuffer_ = _newFrontBuffer;
2158 0 : updatedRegion_ = _updatedRegion;
2159 0 : }
2160 :
2161 : } // namespace layers
2162 : } // namespace mozilla
2163 :
2164 : //-----------------------------------------------------------------------------
2165 : // Method definitions for the IPDL type |struct OpPaintCanvas|
2166 : //
2167 : namespace mozilla {
2168 : namespace layers {
2169 0 : OpPaintCanvas::OpPaintCanvas()
2170 : {
2171 0 : Init();
2172 0 : }
2173 :
2174 0 : OpPaintCanvas::~OpPaintCanvas()
2175 : {
2176 0 : }
2177 :
2178 : bool
2179 0 : OpPaintCanvas::operator==(const OpPaintCanvas& _o) const
2180 : {
2181 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
2182 0 : return false;
2183 : }
2184 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
2185 0 : return false;
2186 : }
2187 0 : if ((!((newFrontBuffer()) == ((_o).newFrontBuffer())))) {
2188 0 : return false;
2189 : }
2190 0 : if ((!((needYFlip()) == ((_o).needYFlip())))) {
2191 0 : return false;
2192 : }
2193 0 : return true;
2194 : }
2195 :
2196 : void
2197 0 : OpPaintCanvas::Init()
2198 : {
2199 0 : }
2200 :
2201 : void
2202 0 : OpPaintCanvas::Assign(
2203 : PLayerParent* _layerParent,
2204 : PLayerChild* _layerChild,
2205 : const CanvasSurface& _newFrontBuffer,
2206 : const bool& _needYFlip)
2207 : {
2208 0 : layerParent_ = _layerParent;
2209 0 : layerChild_ = _layerChild;
2210 0 : newFrontBuffer_ = _newFrontBuffer;
2211 0 : needYFlip_ = _needYFlip;
2212 0 : }
2213 :
2214 : } // namespace layers
2215 : } // namespace mozilla
2216 :
2217 : //-----------------------------------------------------------------------------
2218 : // Method definitions for the IPDL type |struct OpPaintImage|
2219 : //
2220 : namespace mozilla {
2221 : namespace layers {
2222 0 : OpPaintImage::OpPaintImage()
2223 : {
2224 0 : Init();
2225 0 : }
2226 :
2227 0 : OpPaintImage::~OpPaintImage()
2228 : {
2229 0 : }
2230 :
2231 : bool
2232 0 : OpPaintImage::operator==(const OpPaintImage& _o) const
2233 : {
2234 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
2235 0 : return false;
2236 : }
2237 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
2238 0 : return false;
2239 : }
2240 0 : if ((!((newFrontBuffer()) == ((_o).newFrontBuffer())))) {
2241 0 : return false;
2242 : }
2243 0 : return true;
2244 : }
2245 :
2246 : void
2247 0 : OpPaintImage::Init()
2248 : {
2249 0 : }
2250 :
2251 : void
2252 0 : OpPaintImage::Assign(
2253 : PLayerParent* _layerParent,
2254 : PLayerChild* _layerChild,
2255 : const SharedImage& _newFrontBuffer)
2256 : {
2257 0 : layerParent_ = _layerParent;
2258 0 : layerChild_ = _layerChild;
2259 0 : newFrontBuffer_ = _newFrontBuffer;
2260 0 : }
2261 :
2262 : } // namespace layers
2263 : } // namespace mozilla
2264 :
2265 : //-----------------------------------------------------------------------------
2266 : // Method definitions for the IPDL type |union Edit|
2267 : //
2268 : namespace mozilla {
2269 : namespace layers {
2270 : bool
2271 0 : Edit::MaybeDestroy(Type aNewType)
2272 : {
2273 0 : if ((mType) == (T__None)) {
2274 0 : return true;
2275 : }
2276 0 : if ((mType) == (aNewType)) {
2277 0 : return false;
2278 : }
2279 0 : switch (mType) {
2280 : case TOpCreateThebesLayer:
2281 : {
2282 0 : (ptr_OpCreateThebesLayer())->~OpCreateThebesLayer__tdef();
2283 0 : break;
2284 : }
2285 : case TOpCreateContainerLayer:
2286 : {
2287 0 : (ptr_OpCreateContainerLayer())->~OpCreateContainerLayer__tdef();
2288 0 : break;
2289 : }
2290 : case TOpCreateImageLayer:
2291 : {
2292 0 : (ptr_OpCreateImageLayer())->~OpCreateImageLayer__tdef();
2293 0 : break;
2294 : }
2295 : case TOpCreateColorLayer:
2296 : {
2297 0 : (ptr_OpCreateColorLayer())->~OpCreateColorLayer__tdef();
2298 0 : break;
2299 : }
2300 : case TOpCreateCanvasLayer:
2301 : {
2302 0 : (ptr_OpCreateCanvasLayer())->~OpCreateCanvasLayer__tdef();
2303 0 : break;
2304 : }
2305 : case TOpSetLayerAttributes:
2306 : {
2307 0 : (ptr_OpSetLayerAttributes())->~OpSetLayerAttributes__tdef();
2308 0 : break;
2309 : }
2310 : case TOpSetRoot:
2311 : {
2312 0 : (ptr_OpSetRoot())->~OpSetRoot__tdef();
2313 0 : break;
2314 : }
2315 : case TOpInsertAfter:
2316 : {
2317 0 : (ptr_OpInsertAfter())->~OpInsertAfter__tdef();
2318 0 : break;
2319 : }
2320 : case TOpAppendChild:
2321 : {
2322 0 : (ptr_OpAppendChild())->~OpAppendChild__tdef();
2323 0 : break;
2324 : }
2325 : case TOpRemoveChild:
2326 : {
2327 0 : (ptr_OpRemoveChild())->~OpRemoveChild__tdef();
2328 0 : break;
2329 : }
2330 : case TOpPaintThebesBuffer:
2331 : {
2332 0 : (ptr_OpPaintThebesBuffer())->~OpPaintThebesBuffer__tdef();
2333 0 : break;
2334 : }
2335 : case TOpPaintCanvas:
2336 : {
2337 0 : (ptr_OpPaintCanvas())->~OpPaintCanvas__tdef();
2338 0 : break;
2339 : }
2340 : case TOpPaintImage:
2341 : {
2342 0 : (ptr_OpPaintImage())->~OpPaintImage__tdef();
2343 0 : break;
2344 : }
2345 : default:
2346 : {
2347 0 : NS_RUNTIMEABORT("not reached");
2348 0 : break;
2349 : }
2350 : }
2351 0 : return true;
2352 : }
2353 :
2354 0 : Edit::Edit(const OpCreateThebesLayer& aOther)
2355 : {
2356 0 : new (ptr_OpCreateThebesLayer()) OpCreateThebesLayer(aOther);
2357 0 : mType = TOpCreateThebesLayer;
2358 0 : }
2359 :
2360 0 : Edit::Edit(const OpCreateContainerLayer& aOther)
2361 : {
2362 0 : new (ptr_OpCreateContainerLayer()) OpCreateContainerLayer(aOther);
2363 0 : mType = TOpCreateContainerLayer;
2364 0 : }
2365 :
2366 0 : Edit::Edit(const OpCreateImageLayer& aOther)
2367 : {
2368 0 : new (ptr_OpCreateImageLayer()) OpCreateImageLayer(aOther);
2369 0 : mType = TOpCreateImageLayer;
2370 0 : }
2371 :
2372 0 : Edit::Edit(const OpCreateColorLayer& aOther)
2373 : {
2374 0 : new (ptr_OpCreateColorLayer()) OpCreateColorLayer(aOther);
2375 0 : mType = TOpCreateColorLayer;
2376 0 : }
2377 :
2378 0 : Edit::Edit(const OpCreateCanvasLayer& aOther)
2379 : {
2380 0 : new (ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer(aOther);
2381 0 : mType = TOpCreateCanvasLayer;
2382 0 : }
2383 :
2384 0 : Edit::Edit(const OpSetLayerAttributes& aOther)
2385 : {
2386 0 : new (ptr_OpSetLayerAttributes()) OpSetLayerAttributes(aOther);
2387 0 : mType = TOpSetLayerAttributes;
2388 0 : }
2389 :
2390 0 : Edit::Edit(const OpSetRoot& aOther)
2391 : {
2392 0 : new (ptr_OpSetRoot()) OpSetRoot(aOther);
2393 0 : mType = TOpSetRoot;
2394 0 : }
2395 :
2396 0 : Edit::Edit(const OpInsertAfter& aOther)
2397 : {
2398 0 : new (ptr_OpInsertAfter()) OpInsertAfter(aOther);
2399 0 : mType = TOpInsertAfter;
2400 0 : }
2401 :
2402 0 : Edit::Edit(const OpAppendChild& aOther)
2403 : {
2404 0 : new (ptr_OpAppendChild()) OpAppendChild(aOther);
2405 0 : mType = TOpAppendChild;
2406 0 : }
2407 :
2408 0 : Edit::Edit(const OpRemoveChild& aOther)
2409 : {
2410 0 : new (ptr_OpRemoveChild()) OpRemoveChild(aOther);
2411 0 : mType = TOpRemoveChild;
2412 0 : }
2413 :
2414 0 : Edit::Edit(const OpPaintThebesBuffer& aOther)
2415 : {
2416 0 : new (ptr_OpPaintThebesBuffer()) OpPaintThebesBuffer(aOther);
2417 0 : mType = TOpPaintThebesBuffer;
2418 0 : }
2419 :
2420 0 : Edit::Edit(const OpPaintCanvas& aOther)
2421 : {
2422 0 : new (ptr_OpPaintCanvas()) OpPaintCanvas(aOther);
2423 0 : mType = TOpPaintCanvas;
2424 0 : }
2425 :
2426 0 : Edit::Edit(const OpPaintImage& aOther)
2427 : {
2428 0 : new (ptr_OpPaintImage()) OpPaintImage(aOther);
2429 0 : mType = TOpPaintImage;
2430 0 : }
2431 :
2432 0 : Edit::Edit(const Edit& aOther)
2433 : {
2434 0 : (aOther).AssertSanity();
2435 0 : switch ((aOther).type()) {
2436 : case TOpCreateThebesLayer:
2437 : {
2438 0 : new (ptr_OpCreateThebesLayer()) OpCreateThebesLayer((aOther).get_OpCreateThebesLayer());
2439 0 : break;
2440 : }
2441 : case TOpCreateContainerLayer:
2442 : {
2443 0 : new (ptr_OpCreateContainerLayer()) OpCreateContainerLayer((aOther).get_OpCreateContainerLayer());
2444 0 : break;
2445 : }
2446 : case TOpCreateImageLayer:
2447 : {
2448 0 : new (ptr_OpCreateImageLayer()) OpCreateImageLayer((aOther).get_OpCreateImageLayer());
2449 0 : break;
2450 : }
2451 : case TOpCreateColorLayer:
2452 : {
2453 0 : new (ptr_OpCreateColorLayer()) OpCreateColorLayer((aOther).get_OpCreateColorLayer());
2454 0 : break;
2455 : }
2456 : case TOpCreateCanvasLayer:
2457 : {
2458 0 : new (ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer((aOther).get_OpCreateCanvasLayer());
2459 0 : break;
2460 : }
2461 : case TOpSetLayerAttributes:
2462 : {
2463 0 : new (ptr_OpSetLayerAttributes()) OpSetLayerAttributes((aOther).get_OpSetLayerAttributes());
2464 0 : break;
2465 : }
2466 : case TOpSetRoot:
2467 : {
2468 0 : new (ptr_OpSetRoot()) OpSetRoot((aOther).get_OpSetRoot());
2469 0 : break;
2470 : }
2471 : case TOpInsertAfter:
2472 : {
2473 0 : new (ptr_OpInsertAfter()) OpInsertAfter((aOther).get_OpInsertAfter());
2474 0 : break;
2475 : }
2476 : case TOpAppendChild:
2477 : {
2478 0 : new (ptr_OpAppendChild()) OpAppendChild((aOther).get_OpAppendChild());
2479 0 : break;
2480 : }
2481 : case TOpRemoveChild:
2482 : {
2483 0 : new (ptr_OpRemoveChild()) OpRemoveChild((aOther).get_OpRemoveChild());
2484 0 : break;
2485 : }
2486 : case TOpPaintThebesBuffer:
2487 : {
2488 0 : new (ptr_OpPaintThebesBuffer()) OpPaintThebesBuffer((aOther).get_OpPaintThebesBuffer());
2489 0 : break;
2490 : }
2491 : case TOpPaintCanvas:
2492 : {
2493 0 : new (ptr_OpPaintCanvas()) OpPaintCanvas((aOther).get_OpPaintCanvas());
2494 0 : break;
2495 : }
2496 : case TOpPaintImage:
2497 : {
2498 0 : new (ptr_OpPaintImage()) OpPaintImage((aOther).get_OpPaintImage());
2499 0 : break;
2500 : }
2501 : case T__None:
2502 : {
2503 0 : break;
2504 : }
2505 : default:
2506 : {
2507 0 : NS_RUNTIMEABORT("unreached");
2508 0 : return;
2509 : }
2510 : }
2511 0 : mType = (aOther).type();
2512 : }
2513 :
2514 0 : Edit::~Edit()
2515 : {
2516 0 : MaybeDestroy(T__None);
2517 0 : }
2518 :
2519 : Edit&
2520 0 : Edit::operator=(const OpCreateThebesLayer& aRhs)
2521 : {
2522 0 : if (MaybeDestroy(TOpCreateThebesLayer)) {
2523 0 : new (ptr_OpCreateThebesLayer()) OpCreateThebesLayer;
2524 : }
2525 0 : (*(ptr_OpCreateThebesLayer())) = aRhs;
2526 0 : mType = TOpCreateThebesLayer;
2527 0 : return (*(this));
2528 : }
2529 :
2530 : Edit&
2531 0 : Edit::operator=(const OpCreateContainerLayer& aRhs)
2532 : {
2533 0 : if (MaybeDestroy(TOpCreateContainerLayer)) {
2534 0 : new (ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
2535 : }
2536 0 : (*(ptr_OpCreateContainerLayer())) = aRhs;
2537 0 : mType = TOpCreateContainerLayer;
2538 0 : return (*(this));
2539 : }
2540 :
2541 : Edit&
2542 0 : Edit::operator=(const OpCreateImageLayer& aRhs)
2543 : {
2544 0 : if (MaybeDestroy(TOpCreateImageLayer)) {
2545 0 : new (ptr_OpCreateImageLayer()) OpCreateImageLayer;
2546 : }
2547 0 : (*(ptr_OpCreateImageLayer())) = aRhs;
2548 0 : mType = TOpCreateImageLayer;
2549 0 : return (*(this));
2550 : }
2551 :
2552 : Edit&
2553 0 : Edit::operator=(const OpCreateColorLayer& aRhs)
2554 : {
2555 0 : if (MaybeDestroy(TOpCreateColorLayer)) {
2556 0 : new (ptr_OpCreateColorLayer()) OpCreateColorLayer;
2557 : }
2558 0 : (*(ptr_OpCreateColorLayer())) = aRhs;
2559 0 : mType = TOpCreateColorLayer;
2560 0 : return (*(this));
2561 : }
2562 :
2563 : Edit&
2564 0 : Edit::operator=(const OpCreateCanvasLayer& aRhs)
2565 : {
2566 0 : if (MaybeDestroy(TOpCreateCanvasLayer)) {
2567 0 : new (ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
2568 : }
2569 0 : (*(ptr_OpCreateCanvasLayer())) = aRhs;
2570 0 : mType = TOpCreateCanvasLayer;
2571 0 : return (*(this));
2572 : }
2573 :
2574 : Edit&
2575 0 : Edit::operator=(const OpSetLayerAttributes& aRhs)
2576 : {
2577 0 : if (MaybeDestroy(TOpSetLayerAttributes)) {
2578 0 : new (ptr_OpSetLayerAttributes()) OpSetLayerAttributes;
2579 : }
2580 0 : (*(ptr_OpSetLayerAttributes())) = aRhs;
2581 0 : mType = TOpSetLayerAttributes;
2582 0 : return (*(this));
2583 : }
2584 :
2585 : Edit&
2586 0 : Edit::operator=(const OpSetRoot& aRhs)
2587 : {
2588 0 : if (MaybeDestroy(TOpSetRoot)) {
2589 0 : new (ptr_OpSetRoot()) OpSetRoot;
2590 : }
2591 0 : (*(ptr_OpSetRoot())) = aRhs;
2592 0 : mType = TOpSetRoot;
2593 0 : return (*(this));
2594 : }
2595 :
2596 : Edit&
2597 0 : Edit::operator=(const OpInsertAfter& aRhs)
2598 : {
2599 0 : if (MaybeDestroy(TOpInsertAfter)) {
2600 0 : new (ptr_OpInsertAfter()) OpInsertAfter;
2601 : }
2602 0 : (*(ptr_OpInsertAfter())) = aRhs;
2603 0 : mType = TOpInsertAfter;
2604 0 : return (*(this));
2605 : }
2606 :
2607 : Edit&
2608 0 : Edit::operator=(const OpAppendChild& aRhs)
2609 : {
2610 0 : if (MaybeDestroy(TOpAppendChild)) {
2611 0 : new (ptr_OpAppendChild()) OpAppendChild;
2612 : }
2613 0 : (*(ptr_OpAppendChild())) = aRhs;
2614 0 : mType = TOpAppendChild;
2615 0 : return (*(this));
2616 : }
2617 :
2618 : Edit&
2619 0 : Edit::operator=(const OpRemoveChild& aRhs)
2620 : {
2621 0 : if (MaybeDestroy(TOpRemoveChild)) {
2622 0 : new (ptr_OpRemoveChild()) OpRemoveChild;
2623 : }
2624 0 : (*(ptr_OpRemoveChild())) = aRhs;
2625 0 : mType = TOpRemoveChild;
2626 0 : return (*(this));
2627 : }
2628 :
2629 : Edit&
2630 0 : Edit::operator=(const OpPaintThebesBuffer& aRhs)
2631 : {
2632 0 : if (MaybeDestroy(TOpPaintThebesBuffer)) {
2633 0 : new (ptr_OpPaintThebesBuffer()) OpPaintThebesBuffer;
2634 : }
2635 0 : (*(ptr_OpPaintThebesBuffer())) = aRhs;
2636 0 : mType = TOpPaintThebesBuffer;
2637 0 : return (*(this));
2638 : }
2639 :
2640 : Edit&
2641 0 : Edit::operator=(const OpPaintCanvas& aRhs)
2642 : {
2643 0 : if (MaybeDestroy(TOpPaintCanvas)) {
2644 0 : new (ptr_OpPaintCanvas()) OpPaintCanvas;
2645 : }
2646 0 : (*(ptr_OpPaintCanvas())) = aRhs;
2647 0 : mType = TOpPaintCanvas;
2648 0 : return (*(this));
2649 : }
2650 :
2651 : Edit&
2652 0 : Edit::operator=(const OpPaintImage& aRhs)
2653 : {
2654 0 : if (MaybeDestroy(TOpPaintImage)) {
2655 0 : new (ptr_OpPaintImage()) OpPaintImage;
2656 : }
2657 0 : (*(ptr_OpPaintImage())) = aRhs;
2658 0 : mType = TOpPaintImage;
2659 0 : return (*(this));
2660 : }
2661 :
2662 : Edit&
2663 0 : Edit::operator=(const Edit& aRhs)
2664 : {
2665 0 : (aRhs).AssertSanity();
2666 0 : Type t = (aRhs).type();
2667 0 : switch (t) {
2668 : case TOpCreateThebesLayer:
2669 : {
2670 0 : if (MaybeDestroy(t)) {
2671 0 : new (ptr_OpCreateThebesLayer()) OpCreateThebesLayer;
2672 : }
2673 0 : (*(ptr_OpCreateThebesLayer())) = (aRhs).get_OpCreateThebesLayer();
2674 0 : break;
2675 : }
2676 : case TOpCreateContainerLayer:
2677 : {
2678 0 : if (MaybeDestroy(t)) {
2679 0 : new (ptr_OpCreateContainerLayer()) OpCreateContainerLayer;
2680 : }
2681 0 : (*(ptr_OpCreateContainerLayer())) = (aRhs).get_OpCreateContainerLayer();
2682 0 : break;
2683 : }
2684 : case TOpCreateImageLayer:
2685 : {
2686 0 : if (MaybeDestroy(t)) {
2687 0 : new (ptr_OpCreateImageLayer()) OpCreateImageLayer;
2688 : }
2689 0 : (*(ptr_OpCreateImageLayer())) = (aRhs).get_OpCreateImageLayer();
2690 0 : break;
2691 : }
2692 : case TOpCreateColorLayer:
2693 : {
2694 0 : if (MaybeDestroy(t)) {
2695 0 : new (ptr_OpCreateColorLayer()) OpCreateColorLayer;
2696 : }
2697 0 : (*(ptr_OpCreateColorLayer())) = (aRhs).get_OpCreateColorLayer();
2698 0 : break;
2699 : }
2700 : case TOpCreateCanvasLayer:
2701 : {
2702 0 : if (MaybeDestroy(t)) {
2703 0 : new (ptr_OpCreateCanvasLayer()) OpCreateCanvasLayer;
2704 : }
2705 0 : (*(ptr_OpCreateCanvasLayer())) = (aRhs).get_OpCreateCanvasLayer();
2706 0 : break;
2707 : }
2708 : case TOpSetLayerAttributes:
2709 : {
2710 0 : if (MaybeDestroy(t)) {
2711 0 : new (ptr_OpSetLayerAttributes()) OpSetLayerAttributes;
2712 : }
2713 0 : (*(ptr_OpSetLayerAttributes())) = (aRhs).get_OpSetLayerAttributes();
2714 0 : break;
2715 : }
2716 : case TOpSetRoot:
2717 : {
2718 0 : if (MaybeDestroy(t)) {
2719 0 : new (ptr_OpSetRoot()) OpSetRoot;
2720 : }
2721 0 : (*(ptr_OpSetRoot())) = (aRhs).get_OpSetRoot();
2722 0 : break;
2723 : }
2724 : case TOpInsertAfter:
2725 : {
2726 0 : if (MaybeDestroy(t)) {
2727 0 : new (ptr_OpInsertAfter()) OpInsertAfter;
2728 : }
2729 0 : (*(ptr_OpInsertAfter())) = (aRhs).get_OpInsertAfter();
2730 0 : break;
2731 : }
2732 : case TOpAppendChild:
2733 : {
2734 0 : if (MaybeDestroy(t)) {
2735 0 : new (ptr_OpAppendChild()) OpAppendChild;
2736 : }
2737 0 : (*(ptr_OpAppendChild())) = (aRhs).get_OpAppendChild();
2738 0 : break;
2739 : }
2740 : case TOpRemoveChild:
2741 : {
2742 0 : if (MaybeDestroy(t)) {
2743 0 : new (ptr_OpRemoveChild()) OpRemoveChild;
2744 : }
2745 0 : (*(ptr_OpRemoveChild())) = (aRhs).get_OpRemoveChild();
2746 0 : break;
2747 : }
2748 : case TOpPaintThebesBuffer:
2749 : {
2750 0 : if (MaybeDestroy(t)) {
2751 0 : new (ptr_OpPaintThebesBuffer()) OpPaintThebesBuffer;
2752 : }
2753 0 : (*(ptr_OpPaintThebesBuffer())) = (aRhs).get_OpPaintThebesBuffer();
2754 0 : break;
2755 : }
2756 : case TOpPaintCanvas:
2757 : {
2758 0 : if (MaybeDestroy(t)) {
2759 0 : new (ptr_OpPaintCanvas()) OpPaintCanvas;
2760 : }
2761 0 : (*(ptr_OpPaintCanvas())) = (aRhs).get_OpPaintCanvas();
2762 0 : break;
2763 : }
2764 : case TOpPaintImage:
2765 : {
2766 0 : if (MaybeDestroy(t)) {
2767 0 : new (ptr_OpPaintImage()) OpPaintImage;
2768 : }
2769 0 : (*(ptr_OpPaintImage())) = (aRhs).get_OpPaintImage();
2770 0 : break;
2771 : }
2772 : case T__None:
2773 : {
2774 0 : MaybeDestroy(t);
2775 0 : break;
2776 : }
2777 : default:
2778 : {
2779 0 : NS_RUNTIMEABORT("unreached");
2780 0 : break;
2781 : }
2782 : }
2783 0 : mType = t;
2784 0 : return (*(this));
2785 : }
2786 :
2787 : bool
2788 0 : Edit::operator==(const OpCreateThebesLayer& aRhs) const
2789 : {
2790 0 : return (get_OpCreateThebesLayer()) == (aRhs);
2791 : }
2792 :
2793 : bool
2794 0 : Edit::operator==(const OpCreateContainerLayer& aRhs) const
2795 : {
2796 0 : return (get_OpCreateContainerLayer()) == (aRhs);
2797 : }
2798 :
2799 : bool
2800 0 : Edit::operator==(const OpCreateImageLayer& aRhs) const
2801 : {
2802 0 : return (get_OpCreateImageLayer()) == (aRhs);
2803 : }
2804 :
2805 : bool
2806 0 : Edit::operator==(const OpCreateColorLayer& aRhs) const
2807 : {
2808 0 : return (get_OpCreateColorLayer()) == (aRhs);
2809 : }
2810 :
2811 : bool
2812 0 : Edit::operator==(const OpCreateCanvasLayer& aRhs) const
2813 : {
2814 0 : return (get_OpCreateCanvasLayer()) == (aRhs);
2815 : }
2816 :
2817 : bool
2818 0 : Edit::operator==(const OpSetLayerAttributes& aRhs) const
2819 : {
2820 0 : return (get_OpSetLayerAttributes()) == (aRhs);
2821 : }
2822 :
2823 : bool
2824 0 : Edit::operator==(const OpSetRoot& aRhs) const
2825 : {
2826 0 : return (get_OpSetRoot()) == (aRhs);
2827 : }
2828 :
2829 : bool
2830 0 : Edit::operator==(const OpInsertAfter& aRhs) const
2831 : {
2832 0 : return (get_OpInsertAfter()) == (aRhs);
2833 : }
2834 :
2835 : bool
2836 0 : Edit::operator==(const OpAppendChild& aRhs) const
2837 : {
2838 0 : return (get_OpAppendChild()) == (aRhs);
2839 : }
2840 :
2841 : bool
2842 0 : Edit::operator==(const OpRemoveChild& aRhs) const
2843 : {
2844 0 : return (get_OpRemoveChild()) == (aRhs);
2845 : }
2846 :
2847 : bool
2848 0 : Edit::operator==(const OpPaintThebesBuffer& aRhs) const
2849 : {
2850 0 : return (get_OpPaintThebesBuffer()) == (aRhs);
2851 : }
2852 :
2853 : bool
2854 0 : Edit::operator==(const OpPaintCanvas& aRhs) const
2855 : {
2856 0 : return (get_OpPaintCanvas()) == (aRhs);
2857 : }
2858 :
2859 : bool
2860 0 : Edit::operator==(const OpPaintImage& aRhs) const
2861 : {
2862 0 : return (get_OpPaintImage()) == (aRhs);
2863 : }
2864 :
2865 : bool
2866 0 : Edit::operator==(const Edit& aRhs) const
2867 : {
2868 0 : if ((type()) != ((aRhs).type())) {
2869 0 : return false;
2870 : }
2871 :
2872 0 : switch (type()) {
2873 : case TOpCreateThebesLayer:
2874 : {
2875 0 : return (get_OpCreateThebesLayer()) == ((aRhs).get_OpCreateThebesLayer());
2876 : }
2877 : case TOpCreateContainerLayer:
2878 : {
2879 0 : return (get_OpCreateContainerLayer()) == ((aRhs).get_OpCreateContainerLayer());
2880 : }
2881 : case TOpCreateImageLayer:
2882 : {
2883 0 : return (get_OpCreateImageLayer()) == ((aRhs).get_OpCreateImageLayer());
2884 : }
2885 : case TOpCreateColorLayer:
2886 : {
2887 0 : return (get_OpCreateColorLayer()) == ((aRhs).get_OpCreateColorLayer());
2888 : }
2889 : case TOpCreateCanvasLayer:
2890 : {
2891 0 : return (get_OpCreateCanvasLayer()) == ((aRhs).get_OpCreateCanvasLayer());
2892 : }
2893 : case TOpSetLayerAttributes:
2894 : {
2895 0 : return (get_OpSetLayerAttributes()) == ((aRhs).get_OpSetLayerAttributes());
2896 : }
2897 : case TOpSetRoot:
2898 : {
2899 0 : return (get_OpSetRoot()) == ((aRhs).get_OpSetRoot());
2900 : }
2901 : case TOpInsertAfter:
2902 : {
2903 0 : return (get_OpInsertAfter()) == ((aRhs).get_OpInsertAfter());
2904 : }
2905 : case TOpAppendChild:
2906 : {
2907 0 : return (get_OpAppendChild()) == ((aRhs).get_OpAppendChild());
2908 : }
2909 : case TOpRemoveChild:
2910 : {
2911 0 : return (get_OpRemoveChild()) == ((aRhs).get_OpRemoveChild());
2912 : }
2913 : case TOpPaintThebesBuffer:
2914 : {
2915 0 : return (get_OpPaintThebesBuffer()) == ((aRhs).get_OpPaintThebesBuffer());
2916 : }
2917 : case TOpPaintCanvas:
2918 : {
2919 0 : return (get_OpPaintCanvas()) == ((aRhs).get_OpPaintCanvas());
2920 : }
2921 : case TOpPaintImage:
2922 : {
2923 0 : return (get_OpPaintImage()) == ((aRhs).get_OpPaintImage());
2924 : }
2925 : default:
2926 : {
2927 0 : NS_RUNTIMEABORT("unreached");
2928 0 : return false;
2929 : }
2930 : }
2931 : }
2932 :
2933 : } // namespace layers
2934 : } // namespace mozilla
2935 :
2936 : //-----------------------------------------------------------------------------
2937 : // Method definitions for the IPDL type |struct OpBufferSwap|
2938 : //
2939 : namespace mozilla {
2940 : namespace layers {
2941 0 : OpBufferSwap::OpBufferSwap()
2942 : {
2943 0 : Init();
2944 0 : }
2945 :
2946 0 : OpBufferSwap::~OpBufferSwap()
2947 : {
2948 0 : }
2949 :
2950 : bool
2951 0 : OpBufferSwap::operator==(const OpBufferSwap& _o) const
2952 : {
2953 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
2954 0 : return false;
2955 : }
2956 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
2957 0 : return false;
2958 : }
2959 0 : if ((!((newBackBuffer()) == ((_o).newBackBuffer())))) {
2960 0 : return false;
2961 : }
2962 0 : return true;
2963 : }
2964 :
2965 : void
2966 0 : OpBufferSwap::Init()
2967 : {
2968 0 : }
2969 :
2970 : void
2971 0 : OpBufferSwap::Assign(
2972 : PLayerParent* _layerParent,
2973 : PLayerChild* _layerChild,
2974 : const CanvasSurface& _newBackBuffer)
2975 : {
2976 0 : layerParent_ = _layerParent;
2977 0 : layerChild_ = _layerChild;
2978 0 : newBackBuffer_ = _newBackBuffer;
2979 0 : }
2980 :
2981 : } // namespace layers
2982 : } // namespace mozilla
2983 :
2984 : //-----------------------------------------------------------------------------
2985 : // Method definitions for the IPDL type |struct OpImageSwap|
2986 : //
2987 : namespace mozilla {
2988 : namespace layers {
2989 0 : OpImageSwap::OpImageSwap()
2990 : {
2991 0 : Init();
2992 0 : }
2993 :
2994 0 : OpImageSwap::~OpImageSwap()
2995 : {
2996 0 : }
2997 :
2998 : bool
2999 0 : OpImageSwap::operator==(const OpImageSwap& _o) const
3000 : {
3001 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
3002 0 : return false;
3003 : }
3004 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
3005 0 : return false;
3006 : }
3007 0 : if ((!((newBackImage()) == ((_o).newBackImage())))) {
3008 0 : return false;
3009 : }
3010 0 : return true;
3011 : }
3012 :
3013 : void
3014 0 : OpImageSwap::Init()
3015 : {
3016 0 : }
3017 :
3018 : void
3019 0 : OpImageSwap::Assign(
3020 : PLayerParent* _layerParent,
3021 : PLayerChild* _layerChild,
3022 : const SharedImage& _newBackImage)
3023 : {
3024 0 : layerParent_ = _layerParent;
3025 0 : layerChild_ = _layerChild;
3026 0 : newBackImage_ = _newBackImage;
3027 0 : }
3028 :
3029 : } // namespace layers
3030 : } // namespace mozilla
3031 :
3032 : //-----------------------------------------------------------------------------
3033 : // Method definitions for the IPDL type |struct OpThebesBufferSwap|
3034 : //
3035 : namespace mozilla {
3036 : namespace layers {
3037 0 : OpThebesBufferSwap::OpThebesBufferSwap()
3038 : {
3039 0 : Init();
3040 0 : }
3041 :
3042 0 : OpThebesBufferSwap::~OpThebesBufferSwap()
3043 : {
3044 0 : }
3045 :
3046 : bool
3047 0 : OpThebesBufferSwap::operator==(const OpThebesBufferSwap& _o) const
3048 : {
3049 0 : if ((!((layerParent()) == ((_o).layerParent())))) {
3050 0 : return false;
3051 : }
3052 0 : if ((!((layerChild()) == ((_o).layerChild())))) {
3053 0 : return false;
3054 : }
3055 0 : if ((!((newBackBuffer()) == ((_o).newBackBuffer())))) {
3056 0 : return false;
3057 : }
3058 0 : if ((!((newValidRegion()) == ((_o).newValidRegion())))) {
3059 0 : return false;
3060 : }
3061 0 : if ((!((readOnlyFrontBuffer()) == ((_o).readOnlyFrontBuffer())))) {
3062 0 : return false;
3063 : }
3064 0 : if ((!((frontUpdatedRegion()) == ((_o).frontUpdatedRegion())))) {
3065 0 : return false;
3066 : }
3067 0 : return true;
3068 : }
3069 :
3070 : void
3071 0 : OpThebesBufferSwap::Init()
3072 : {
3073 0 : }
3074 :
3075 : void
3076 0 : OpThebesBufferSwap::Assign(
3077 : PLayerParent* _layerParent,
3078 : PLayerChild* _layerChild,
3079 : const OptionalThebesBuffer& _newBackBuffer,
3080 : const nsIntRegion& _newValidRegion,
3081 : const OptionalThebesBuffer& _readOnlyFrontBuffer,
3082 : const nsIntRegion& _frontUpdatedRegion)
3083 : {
3084 0 : layerParent_ = _layerParent;
3085 0 : layerChild_ = _layerChild;
3086 0 : newBackBuffer_ = _newBackBuffer;
3087 0 : newValidRegion_ = _newValidRegion;
3088 0 : readOnlyFrontBuffer_ = _readOnlyFrontBuffer;
3089 0 : frontUpdatedRegion_ = _frontUpdatedRegion;
3090 0 : }
3091 :
3092 : } // namespace layers
3093 : } // namespace mozilla
3094 :
3095 : //-----------------------------------------------------------------------------
3096 : // Method definitions for the IPDL type |union EditReply|
3097 : //
3098 : namespace mozilla {
3099 : namespace layers {
3100 : bool
3101 0 : EditReply::MaybeDestroy(Type aNewType)
3102 : {
3103 0 : if ((mType) == (T__None)) {
3104 0 : return true;
3105 : }
3106 0 : if ((mType) == (aNewType)) {
3107 0 : return false;
3108 : }
3109 0 : switch (mType) {
3110 : case TOpBufferSwap:
3111 : {
3112 0 : (ptr_OpBufferSwap())->~OpBufferSwap__tdef();
3113 0 : break;
3114 : }
3115 : case TOpThebesBufferSwap:
3116 : {
3117 0 : (ptr_OpThebesBufferSwap())->~OpThebesBufferSwap__tdef();
3118 0 : break;
3119 : }
3120 : case TOpImageSwap:
3121 : {
3122 0 : (ptr_OpImageSwap())->~OpImageSwap__tdef();
3123 0 : break;
3124 : }
3125 : default:
3126 : {
3127 0 : NS_RUNTIMEABORT("not reached");
3128 0 : break;
3129 : }
3130 : }
3131 0 : return true;
3132 : }
3133 :
3134 0 : EditReply::EditReply(const OpBufferSwap& aOther)
3135 : {
3136 0 : new (ptr_OpBufferSwap()) OpBufferSwap(aOther);
3137 0 : mType = TOpBufferSwap;
3138 0 : }
3139 :
3140 0 : EditReply::EditReply(const OpThebesBufferSwap& aOther)
3141 : {
3142 0 : new (ptr_OpThebesBufferSwap()) OpThebesBufferSwap(aOther);
3143 0 : mType = TOpThebesBufferSwap;
3144 0 : }
3145 :
3146 0 : EditReply::EditReply(const OpImageSwap& aOther)
3147 : {
3148 0 : new (ptr_OpImageSwap()) OpImageSwap(aOther);
3149 0 : mType = TOpImageSwap;
3150 0 : }
3151 :
3152 0 : EditReply::EditReply(const EditReply& aOther)
3153 : {
3154 0 : (aOther).AssertSanity();
3155 0 : switch ((aOther).type()) {
3156 : case TOpBufferSwap:
3157 : {
3158 0 : new (ptr_OpBufferSwap()) OpBufferSwap((aOther).get_OpBufferSwap());
3159 0 : break;
3160 : }
3161 : case TOpThebesBufferSwap:
3162 : {
3163 0 : new (ptr_OpThebesBufferSwap()) OpThebesBufferSwap((aOther).get_OpThebesBufferSwap());
3164 0 : break;
3165 : }
3166 : case TOpImageSwap:
3167 : {
3168 0 : new (ptr_OpImageSwap()) OpImageSwap((aOther).get_OpImageSwap());
3169 0 : break;
3170 : }
3171 : case T__None:
3172 : {
3173 0 : break;
3174 : }
3175 : default:
3176 : {
3177 0 : NS_RUNTIMEABORT("unreached");
3178 0 : return;
3179 : }
3180 : }
3181 0 : mType = (aOther).type();
3182 : }
3183 :
3184 0 : EditReply::~EditReply()
3185 : {
3186 0 : MaybeDestroy(T__None);
3187 0 : }
3188 :
3189 : EditReply&
3190 0 : EditReply::operator=(const OpBufferSwap& aRhs)
3191 : {
3192 0 : if (MaybeDestroy(TOpBufferSwap)) {
3193 0 : new (ptr_OpBufferSwap()) OpBufferSwap;
3194 : }
3195 0 : (*(ptr_OpBufferSwap())) = aRhs;
3196 0 : mType = TOpBufferSwap;
3197 0 : return (*(this));
3198 : }
3199 :
3200 : EditReply&
3201 0 : EditReply::operator=(const OpThebesBufferSwap& aRhs)
3202 : {
3203 0 : if (MaybeDestroy(TOpThebesBufferSwap)) {
3204 0 : new (ptr_OpThebesBufferSwap()) OpThebesBufferSwap;
3205 : }
3206 0 : (*(ptr_OpThebesBufferSwap())) = aRhs;
3207 0 : mType = TOpThebesBufferSwap;
3208 0 : return (*(this));
3209 : }
3210 :
3211 : EditReply&
3212 0 : EditReply::operator=(const OpImageSwap& aRhs)
3213 : {
3214 0 : if (MaybeDestroy(TOpImageSwap)) {
3215 0 : new (ptr_OpImageSwap()) OpImageSwap;
3216 : }
3217 0 : (*(ptr_OpImageSwap())) = aRhs;
3218 0 : mType = TOpImageSwap;
3219 0 : return (*(this));
3220 : }
3221 :
3222 : EditReply&
3223 0 : EditReply::operator=(const EditReply& aRhs)
3224 : {
3225 0 : (aRhs).AssertSanity();
3226 0 : Type t = (aRhs).type();
3227 0 : switch (t) {
3228 : case TOpBufferSwap:
3229 : {
3230 0 : if (MaybeDestroy(t)) {
3231 0 : new (ptr_OpBufferSwap()) OpBufferSwap;
3232 : }
3233 0 : (*(ptr_OpBufferSwap())) = (aRhs).get_OpBufferSwap();
3234 0 : break;
3235 : }
3236 : case TOpThebesBufferSwap:
3237 : {
3238 0 : if (MaybeDestroy(t)) {
3239 0 : new (ptr_OpThebesBufferSwap()) OpThebesBufferSwap;
3240 : }
3241 0 : (*(ptr_OpThebesBufferSwap())) = (aRhs).get_OpThebesBufferSwap();
3242 0 : break;
3243 : }
3244 : case TOpImageSwap:
3245 : {
3246 0 : if (MaybeDestroy(t)) {
3247 0 : new (ptr_OpImageSwap()) OpImageSwap;
3248 : }
3249 0 : (*(ptr_OpImageSwap())) = (aRhs).get_OpImageSwap();
3250 0 : break;
3251 : }
3252 : case T__None:
3253 : {
3254 0 : MaybeDestroy(t);
3255 0 : break;
3256 : }
3257 : default:
3258 : {
3259 0 : NS_RUNTIMEABORT("unreached");
3260 0 : break;
3261 : }
3262 : }
3263 0 : mType = t;
3264 0 : return (*(this));
3265 : }
3266 :
3267 : bool
3268 0 : EditReply::operator==(const OpBufferSwap& aRhs) const
3269 : {
3270 0 : return (get_OpBufferSwap()) == (aRhs);
3271 : }
3272 :
3273 : bool
3274 0 : EditReply::operator==(const OpThebesBufferSwap& aRhs) const
3275 : {
3276 0 : return (get_OpThebesBufferSwap()) == (aRhs);
3277 : }
3278 :
3279 : bool
3280 0 : EditReply::operator==(const OpImageSwap& aRhs) const
3281 : {
3282 0 : return (get_OpImageSwap()) == (aRhs);
3283 : }
3284 :
3285 : bool
3286 0 : EditReply::operator==(const EditReply& aRhs) const
3287 : {
3288 0 : if ((type()) != ((aRhs).type())) {
3289 0 : return false;
3290 : }
3291 :
3292 0 : switch (type()) {
3293 : case TOpBufferSwap:
3294 : {
3295 0 : return (get_OpBufferSwap()) == ((aRhs).get_OpBufferSwap());
3296 : }
3297 : case TOpThebesBufferSwap:
3298 : {
3299 0 : return (get_OpThebesBufferSwap()) == ((aRhs).get_OpThebesBufferSwap());
3300 : }
3301 : case TOpImageSwap:
3302 : {
3303 0 : return (get_OpImageSwap()) == ((aRhs).get_OpImageSwap());
3304 : }
3305 : default:
3306 : {
3307 0 : NS_RUNTIMEABORT("unreached");
3308 0 : return false;
3309 : }
3310 : }
3311 : }
3312 :
3313 : } // namespace layers
3314 : } // namespace mozilla
|