1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 : #ifndef PLayers_h
7 : #define PLayers_h
8 :
9 : #include "mozilla/Attributes.h"
10 : #include "base/basictypes.h"
11 : #include "prtime.h"
12 : #include "nscore.h"
13 : #include "IPCMessageStart.h"
14 : #include "IPC/IPCMessageUtils.h"
15 : #include "nsAutoPtr.h"
16 : #include "nsStringGlue.h"
17 : #include "nsTArray.h"
18 : #include "nsIFile.h"
19 : #include "mozilla/ipc/ProtocolUtils.h"
20 : #include "gfxipc/ShadowLayerUtils.h"
21 :
22 : namespace mozilla {
23 : namespace layers {
24 : class PLayerParent;
25 : } // namespace layers
26 : } // namespace mozilla
27 :
28 : namespace mozilla {
29 : namespace layers {
30 : class PLayerChild;
31 : } // namespace layers
32 : } // namespace mozilla
33 :
34 :
35 : //-----------------------------------------------------------------------------
36 : // Declaration of the IPDL type |struct OpCreateThebesLayer|
37 : //
38 : namespace mozilla {
39 : namespace layers {
40 : class OpCreateThebesLayer MOZ_FINAL
41 : {
42 : private:
43 : typedef mozilla::layers::PLayerParent PLayerParent;
44 : typedef mozilla::layers::PLayerChild PLayerChild;
45 :
46 : public:
47 : OpCreateThebesLayer();
48 :
49 0 : OpCreateThebesLayer(
50 : PLayerParent* _layerParent,
51 : PLayerChild* _layerChild)
52 : {
53 0 : Init();
54 0 : Assign(_layerParent, _layerChild);
55 0 : }
56 :
57 0 : OpCreateThebesLayer(const OpCreateThebesLayer& _o)
58 : {
59 0 : Init();
60 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
61 0 : }
62 :
63 : ~OpCreateThebesLayer();
64 :
65 : void
66 0 : operator=(const OpCreateThebesLayer& _o)
67 : {
68 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
69 0 : }
70 :
71 : bool
72 : operator==(const OpCreateThebesLayer& _o) const;
73 :
74 : PLayerParent*&
75 0 : layerParent()
76 : {
77 0 : return layerParent_;
78 : }
79 : PLayerParent*
80 0 : layerParent() const
81 : {
82 0 : return layerParent_;
83 : }
84 :
85 : PLayerChild*&
86 0 : layerChild()
87 : {
88 0 : return layerChild_;
89 : }
90 : PLayerChild*
91 0 : layerChild() const
92 : {
93 0 : return layerChild_;
94 : }
95 :
96 : private:
97 : void
98 : Init();
99 :
100 : void
101 : Assign(
102 : PLayerParent* _layerParent,
103 : PLayerChild* _layerChild);
104 :
105 : PLayerParent* layerParent_;
106 : PLayerChild* layerChild_;
107 : };
108 : } // namespace layers
109 : } // namespace mozilla
110 :
111 : namespace mozilla {
112 : namespace layers {
113 : class PLayerParent;
114 : } // namespace layers
115 : } // namespace mozilla
116 :
117 : namespace mozilla {
118 : namespace layers {
119 : class PLayerChild;
120 : } // namespace layers
121 : } // namespace mozilla
122 :
123 :
124 : //-----------------------------------------------------------------------------
125 : // Declaration of the IPDL type |struct OpCreateContainerLayer|
126 : //
127 : namespace mozilla {
128 : namespace layers {
129 : class OpCreateContainerLayer MOZ_FINAL
130 : {
131 : private:
132 : typedef mozilla::layers::PLayerParent PLayerParent;
133 : typedef mozilla::layers::PLayerChild PLayerChild;
134 :
135 : public:
136 : OpCreateContainerLayer();
137 :
138 0 : OpCreateContainerLayer(
139 : PLayerParent* _layerParent,
140 : PLayerChild* _layerChild)
141 : {
142 0 : Init();
143 0 : Assign(_layerParent, _layerChild);
144 0 : }
145 :
146 0 : OpCreateContainerLayer(const OpCreateContainerLayer& _o)
147 : {
148 0 : Init();
149 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
150 0 : }
151 :
152 : ~OpCreateContainerLayer();
153 :
154 : void
155 0 : operator=(const OpCreateContainerLayer& _o)
156 : {
157 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
158 0 : }
159 :
160 : bool
161 : operator==(const OpCreateContainerLayer& _o) const;
162 :
163 : PLayerParent*&
164 0 : layerParent()
165 : {
166 0 : return layerParent_;
167 : }
168 : PLayerParent*
169 0 : layerParent() const
170 : {
171 0 : return layerParent_;
172 : }
173 :
174 : PLayerChild*&
175 0 : layerChild()
176 : {
177 0 : return layerChild_;
178 : }
179 : PLayerChild*
180 0 : layerChild() const
181 : {
182 0 : return layerChild_;
183 : }
184 :
185 : private:
186 : void
187 : Init();
188 :
189 : void
190 : Assign(
191 : PLayerParent* _layerParent,
192 : PLayerChild* _layerChild);
193 :
194 : PLayerParent* layerParent_;
195 : PLayerChild* layerChild_;
196 : };
197 : } // namespace layers
198 : } // namespace mozilla
199 :
200 : namespace mozilla {
201 : namespace layers {
202 : class PLayerParent;
203 : } // namespace layers
204 : } // namespace mozilla
205 :
206 : namespace mozilla {
207 : namespace layers {
208 : class PLayerChild;
209 : } // namespace layers
210 : } // namespace mozilla
211 :
212 :
213 : //-----------------------------------------------------------------------------
214 : // Declaration of the IPDL type |struct OpCreateImageLayer|
215 : //
216 : namespace mozilla {
217 : namespace layers {
218 : class OpCreateImageLayer MOZ_FINAL
219 : {
220 : private:
221 : typedef mozilla::layers::PLayerParent PLayerParent;
222 : typedef mozilla::layers::PLayerChild PLayerChild;
223 :
224 : public:
225 : OpCreateImageLayer();
226 :
227 0 : OpCreateImageLayer(
228 : PLayerParent* _layerParent,
229 : PLayerChild* _layerChild)
230 : {
231 0 : Init();
232 0 : Assign(_layerParent, _layerChild);
233 0 : }
234 :
235 0 : OpCreateImageLayer(const OpCreateImageLayer& _o)
236 : {
237 0 : Init();
238 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
239 0 : }
240 :
241 : ~OpCreateImageLayer();
242 :
243 : void
244 0 : operator=(const OpCreateImageLayer& _o)
245 : {
246 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
247 0 : }
248 :
249 : bool
250 : operator==(const OpCreateImageLayer& _o) const;
251 :
252 : PLayerParent*&
253 0 : layerParent()
254 : {
255 0 : return layerParent_;
256 : }
257 : PLayerParent*
258 0 : layerParent() const
259 : {
260 0 : return layerParent_;
261 : }
262 :
263 : PLayerChild*&
264 0 : layerChild()
265 : {
266 0 : return layerChild_;
267 : }
268 : PLayerChild*
269 0 : layerChild() const
270 : {
271 0 : return layerChild_;
272 : }
273 :
274 : private:
275 : void
276 : Init();
277 :
278 : void
279 : Assign(
280 : PLayerParent* _layerParent,
281 : PLayerChild* _layerChild);
282 :
283 : PLayerParent* layerParent_;
284 : PLayerChild* layerChild_;
285 : };
286 : } // namespace layers
287 : } // namespace mozilla
288 :
289 : namespace mozilla {
290 : namespace layers {
291 : class PLayerParent;
292 : } // namespace layers
293 : } // namespace mozilla
294 :
295 : namespace mozilla {
296 : namespace layers {
297 : class PLayerChild;
298 : } // namespace layers
299 : } // namespace mozilla
300 :
301 :
302 : //-----------------------------------------------------------------------------
303 : // Declaration of the IPDL type |struct OpCreateColorLayer|
304 : //
305 : namespace mozilla {
306 : namespace layers {
307 : class OpCreateColorLayer MOZ_FINAL
308 : {
309 : private:
310 : typedef mozilla::layers::PLayerParent PLayerParent;
311 : typedef mozilla::layers::PLayerChild PLayerChild;
312 :
313 : public:
314 : OpCreateColorLayer();
315 :
316 0 : OpCreateColorLayer(
317 : PLayerParent* _layerParent,
318 : PLayerChild* _layerChild)
319 : {
320 0 : Init();
321 0 : Assign(_layerParent, _layerChild);
322 0 : }
323 :
324 0 : OpCreateColorLayer(const OpCreateColorLayer& _o)
325 : {
326 0 : Init();
327 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
328 0 : }
329 :
330 : ~OpCreateColorLayer();
331 :
332 : void
333 0 : operator=(const OpCreateColorLayer& _o)
334 : {
335 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
336 0 : }
337 :
338 : bool
339 : operator==(const OpCreateColorLayer& _o) const;
340 :
341 : PLayerParent*&
342 0 : layerParent()
343 : {
344 0 : return layerParent_;
345 : }
346 : PLayerParent*
347 0 : layerParent() const
348 : {
349 0 : return layerParent_;
350 : }
351 :
352 : PLayerChild*&
353 0 : layerChild()
354 : {
355 0 : return layerChild_;
356 : }
357 : PLayerChild*
358 0 : layerChild() const
359 : {
360 0 : return layerChild_;
361 : }
362 :
363 : private:
364 : void
365 : Init();
366 :
367 : void
368 : Assign(
369 : PLayerParent* _layerParent,
370 : PLayerChild* _layerChild);
371 :
372 : PLayerParent* layerParent_;
373 : PLayerChild* layerChild_;
374 : };
375 : } // namespace layers
376 : } // namespace mozilla
377 :
378 : namespace mozilla {
379 : namespace layers {
380 : class PLayerParent;
381 : } // namespace layers
382 : } // namespace mozilla
383 :
384 : namespace mozilla {
385 : namespace layers {
386 : class PLayerChild;
387 : } // namespace layers
388 : } // namespace mozilla
389 :
390 :
391 : //-----------------------------------------------------------------------------
392 : // Declaration of the IPDL type |struct OpCreateCanvasLayer|
393 : //
394 : namespace mozilla {
395 : namespace layers {
396 : class OpCreateCanvasLayer MOZ_FINAL
397 : {
398 : private:
399 : typedef mozilla::layers::PLayerParent PLayerParent;
400 : typedef mozilla::layers::PLayerChild PLayerChild;
401 :
402 : public:
403 : OpCreateCanvasLayer();
404 :
405 0 : OpCreateCanvasLayer(
406 : PLayerParent* _layerParent,
407 : PLayerChild* _layerChild)
408 : {
409 0 : Init();
410 0 : Assign(_layerParent, _layerChild);
411 0 : }
412 :
413 0 : OpCreateCanvasLayer(const OpCreateCanvasLayer& _o)
414 : {
415 0 : Init();
416 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
417 0 : }
418 :
419 : ~OpCreateCanvasLayer();
420 :
421 : void
422 0 : operator=(const OpCreateCanvasLayer& _o)
423 : {
424 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()));
425 0 : }
426 :
427 : bool
428 : operator==(const OpCreateCanvasLayer& _o) const;
429 :
430 : PLayerParent*&
431 0 : layerParent()
432 : {
433 0 : return layerParent_;
434 : }
435 : PLayerParent*
436 0 : layerParent() const
437 : {
438 0 : return layerParent_;
439 : }
440 :
441 : PLayerChild*&
442 0 : layerChild()
443 : {
444 0 : return layerChild_;
445 : }
446 : PLayerChild*
447 0 : layerChild() const
448 : {
449 0 : return layerChild_;
450 : }
451 :
452 : private:
453 : void
454 : Init();
455 :
456 : void
457 : Assign(
458 : PLayerParent* _layerParent,
459 : PLayerChild* _layerChild);
460 :
461 : PLayerParent* layerParent_;
462 : PLayerChild* layerChild_;
463 : };
464 : } // namespace layers
465 : } // namespace mozilla
466 :
467 :
468 : //-----------------------------------------------------------------------------
469 : // Declaration of the IPDL type |struct SurfaceDescriptorD3D10|
470 : //
471 : namespace mozilla {
472 : namespace layers {
473 : class SurfaceDescriptorD3D10 MOZ_FINAL
474 : {
475 : private:
476 : typedef mozilla::WindowsHandle WindowsHandle;
477 :
478 : public:
479 : SurfaceDescriptorD3D10();
480 :
481 : SurfaceDescriptorD3D10(const WindowsHandle& _handle)
482 : {
483 : Init();
484 : Assign(_handle);
485 : }
486 :
487 0 : SurfaceDescriptorD3D10(const SurfaceDescriptorD3D10& _o)
488 : {
489 0 : Init();
490 0 : Assign((_o).handle());
491 0 : }
492 :
493 : ~SurfaceDescriptorD3D10();
494 :
495 : void
496 0 : operator=(const SurfaceDescriptorD3D10& _o)
497 : {
498 0 : Assign((_o).handle());
499 0 : }
500 :
501 : bool
502 : operator==(const SurfaceDescriptorD3D10& _o) const;
503 :
504 : WindowsHandle&
505 0 : handle()
506 : {
507 0 : return handle_;
508 : }
509 : const WindowsHandle&
510 0 : handle() const
511 : {
512 0 : return handle_;
513 : }
514 :
515 : private:
516 : void
517 : Init();
518 :
519 : void
520 : Assign(const WindowsHandle& _handle);
521 :
522 : WindowsHandle handle_;
523 : };
524 : } // namespace layers
525 : } // namespace mozilla
526 :
527 : namespace mozilla {
528 : namespace layers {
529 : class SurfaceDescriptorD3D10;
530 : } // namespace layers
531 : } // namespace mozilla
532 :
533 : //-----------------------------------------------------------------------------
534 : // Declaration of the IPDL type |union SurfaceDescriptor|
535 : //
536 : namespace mozilla {
537 : namespace layers {
538 : class SurfaceDescriptor MOZ_FINAL
539 : {
540 : public:
541 : enum Type {
542 : T__None,
543 : TShmem = 1,
544 : TSurfaceDescriptorD3D10,
545 : TSurfaceDescriptorX11,
546 : T__Last = TSurfaceDescriptorX11
547 : };
548 :
549 : private:
550 : typedef mozilla::ipc::Shmem Shmem;
551 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
552 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
553 : typedef Shmem Shmem__tdef;
554 : typedef SurfaceDescriptorD3D10 SurfaceDescriptorD3D10__tdef;
555 : typedef SurfaceDescriptorX11 SurfaceDescriptorX11__tdef;
556 :
557 : union Value {
558 : char VShmem[sizeof(Shmem)];
559 : char VSurfaceDescriptorD3D10[sizeof(SurfaceDescriptorD3D10)];
560 : char VSurfaceDescriptorX11[sizeof(SurfaceDescriptorX11)];
561 : };
562 :
563 : Shmem*
564 0 : ptr_Shmem()
565 : {
566 0 : return reinterpret_cast<Shmem*>((&((mValue).VShmem)));
567 : }
568 : const Shmem* const
569 0 : constptr_Shmem() const
570 : {
571 0 : return reinterpret_cast<const Shmem* const>((&((mValue).VShmem)));
572 : }
573 : SurfaceDescriptorD3D10*
574 0 : ptr_SurfaceDescriptorD3D10()
575 : {
576 0 : return reinterpret_cast<SurfaceDescriptorD3D10*>((&((mValue).VSurfaceDescriptorD3D10)));
577 : }
578 : const SurfaceDescriptorD3D10* const
579 0 : constptr_SurfaceDescriptorD3D10() const
580 : {
581 0 : return reinterpret_cast<const SurfaceDescriptorD3D10* const>((&((mValue).VSurfaceDescriptorD3D10)));
582 : }
583 : SurfaceDescriptorX11*
584 0 : ptr_SurfaceDescriptorX11()
585 : {
586 0 : return reinterpret_cast<SurfaceDescriptorX11*>((&((mValue).VSurfaceDescriptorX11)));
587 : }
588 : const SurfaceDescriptorX11* const
589 0 : constptr_SurfaceDescriptorX11() const
590 : {
591 0 : return reinterpret_cast<const SurfaceDescriptorX11* const>((&((mValue).VSurfaceDescriptorX11)));
592 : }
593 :
594 : bool
595 : MaybeDestroy(Type aNewType);
596 :
597 : void
598 0 : AssertSanity() const
599 : {
600 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
601 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
602 0 : }
603 : void
604 0 : AssertSanity(Type aType) const
605 : {
606 0 : AssertSanity();
607 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
608 0 : }
609 :
610 : public:
611 0 : SurfaceDescriptor() :
612 0 : mType(T__None)
613 : {
614 0 : }
615 :
616 : SurfaceDescriptor(Shmem& aOther);
617 :
618 : SurfaceDescriptor(const SurfaceDescriptorD3D10& aOther);
619 :
620 : SurfaceDescriptor(const SurfaceDescriptorX11& aOther);
621 :
622 : SurfaceDescriptor(const SurfaceDescriptor& aOther);
623 :
624 : ~SurfaceDescriptor();
625 :
626 : Type
627 0 : type() const
628 : {
629 0 : return mType;
630 : }
631 :
632 : SurfaceDescriptor&
633 : operator=(Shmem& aRhs);
634 :
635 : SurfaceDescriptor&
636 : operator=(const SurfaceDescriptorD3D10& aRhs);
637 :
638 : SurfaceDescriptor&
639 : operator=(const SurfaceDescriptorX11& aRhs);
640 :
641 : SurfaceDescriptor&
642 : operator=(const SurfaceDescriptor& aRhs);
643 :
644 : bool
645 : operator==(Shmem& aRhs) const;
646 :
647 : bool
648 : operator==(const SurfaceDescriptorD3D10& aRhs) const;
649 :
650 : bool
651 : operator==(const SurfaceDescriptorX11& aRhs) const;
652 :
653 : bool
654 : operator==(const SurfaceDescriptor& aRhs) const;
655 :
656 : Shmem&
657 0 : get_Shmem()
658 : {
659 0 : AssertSanity(TShmem);
660 0 : return (*(ptr_Shmem()));
661 : }
662 : Shmem&
663 0 : get_Shmem() const
664 : {
665 0 : AssertSanity(TShmem);
666 0 : return const_cast<Shmem&>((*(constptr_Shmem())));
667 : }
668 : operator Shmem&()
669 : {
670 : return get_Shmem();
671 : }
672 : operator Shmem&() const
673 : {
674 : return get_Shmem();
675 : }
676 :
677 : SurfaceDescriptorD3D10&
678 0 : get_SurfaceDescriptorD3D10()
679 : {
680 0 : AssertSanity(TSurfaceDescriptorD3D10);
681 0 : return (*(ptr_SurfaceDescriptorD3D10()));
682 : }
683 : const SurfaceDescriptorD3D10&
684 0 : get_SurfaceDescriptorD3D10() const
685 : {
686 0 : AssertSanity(TSurfaceDescriptorD3D10);
687 0 : return (*(constptr_SurfaceDescriptorD3D10()));
688 : }
689 : operator SurfaceDescriptorD3D10&()
690 : {
691 : return get_SurfaceDescriptorD3D10();
692 : }
693 : operator const SurfaceDescriptorD3D10&() const
694 : {
695 : return get_SurfaceDescriptorD3D10();
696 : }
697 :
698 : SurfaceDescriptorX11&
699 0 : get_SurfaceDescriptorX11()
700 : {
701 0 : AssertSanity(TSurfaceDescriptorX11);
702 0 : return (*(ptr_SurfaceDescriptorX11()));
703 : }
704 : const SurfaceDescriptorX11&
705 0 : get_SurfaceDescriptorX11() const
706 : {
707 0 : AssertSanity(TSurfaceDescriptorX11);
708 0 : return (*(constptr_SurfaceDescriptorX11()));
709 : }
710 : operator SurfaceDescriptorX11&()
711 : {
712 : return get_SurfaceDescriptorX11();
713 : }
714 : operator const SurfaceDescriptorX11&() const
715 : {
716 : return get_SurfaceDescriptorX11();
717 : }
718 :
719 : private:
720 : Value mValue;
721 : Type mType;
722 : };
723 : } // namespace layers
724 : } // namespace mozilla
725 :
726 :
727 : //-----------------------------------------------------------------------------
728 : // Declaration of the IPDL type |struct YUVImage|
729 : //
730 : namespace mozilla {
731 : namespace layers {
732 : class YUVImage MOZ_FINAL
733 : {
734 : private:
735 : typedef mozilla::ipc::Shmem Shmem;
736 :
737 : public:
738 : YUVImage();
739 :
740 0 : YUVImage(
741 : Shmem& _Ydata,
742 : Shmem& _Udata,
743 : Shmem& _Vdata,
744 : const nsIntRect& _picture)
745 0 : {
746 0 : Init();
747 0 : Assign(_Ydata, _Udata, _Vdata, _picture);
748 0 : }
749 :
750 0 : YUVImage(const YUVImage& _o)
751 0 : {
752 0 : Init();
753 0 : Assign((_o).Ydata(), (_o).Udata(), (_o).Vdata(), (_o).picture());
754 0 : }
755 :
756 : ~YUVImage();
757 :
758 : void
759 0 : operator=(const YUVImage& _o)
760 : {
761 0 : Assign((_o).Ydata(), (_o).Udata(), (_o).Vdata(), (_o).picture());
762 0 : }
763 :
764 : bool
765 : operator==(const YUVImage& _o) const;
766 :
767 : Shmem&
768 0 : Ydata()
769 : {
770 0 : return Ydata_;
771 : }
772 : Shmem&
773 0 : Ydata() const
774 : {
775 0 : return const_cast<Shmem&>(Ydata_);
776 : }
777 :
778 : Shmem&
779 0 : Udata()
780 : {
781 0 : return Udata_;
782 : }
783 : Shmem&
784 0 : Udata() const
785 : {
786 0 : return const_cast<Shmem&>(Udata_);
787 : }
788 :
789 : Shmem&
790 0 : Vdata()
791 : {
792 0 : return Vdata_;
793 : }
794 : Shmem&
795 0 : Vdata() const
796 : {
797 0 : return const_cast<Shmem&>(Vdata_);
798 : }
799 :
800 : nsIntRect&
801 0 : picture()
802 : {
803 0 : return picture_;
804 : }
805 : const nsIntRect&
806 0 : picture() const
807 : {
808 0 : return picture_;
809 : }
810 :
811 : private:
812 : void
813 : Init();
814 :
815 : void
816 : Assign(
817 : Shmem& _Ydata,
818 : Shmem& _Udata,
819 : Shmem& _Vdata,
820 : const nsIntRect& _picture);
821 :
822 : Shmem Ydata_;
823 : Shmem Udata_;
824 : Shmem Vdata_;
825 : nsIntRect picture_;
826 : };
827 : } // namespace layers
828 : } // namespace mozilla
829 :
830 : namespace mozilla {
831 : namespace layers {
832 : class SurfaceDescriptor;
833 : } // namespace layers
834 : } // namespace mozilla
835 : namespace mozilla {
836 : namespace layers {
837 : class YUVImage;
838 : } // namespace layers
839 : } // namespace mozilla
840 :
841 : //-----------------------------------------------------------------------------
842 : // Declaration of the IPDL type |union SharedImage|
843 : //
844 : namespace mozilla {
845 : namespace layers {
846 : class SharedImage MOZ_FINAL
847 : {
848 : public:
849 : enum Type {
850 : T__None,
851 : TSurfaceDescriptor = 1,
852 : TYUVImage,
853 : Tnull_t,
854 : T__Last = Tnull_t
855 : };
856 :
857 : private:
858 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
859 : typedef mozilla::layers::YUVImage YUVImage;
860 : typedef mozilla::null_t null_t;
861 : typedef SurfaceDescriptor SurfaceDescriptor__tdef;
862 : typedef YUVImage YUVImage__tdef;
863 : typedef null_t null_t__tdef;
864 :
865 : union Value {
866 : char VSurfaceDescriptor[sizeof(SurfaceDescriptor)];
867 : char VYUVImage[sizeof(YUVImage)];
868 : char Vnull_t[sizeof(null_t)];
869 : };
870 :
871 : SurfaceDescriptor*
872 0 : ptr_SurfaceDescriptor()
873 : {
874 0 : return reinterpret_cast<SurfaceDescriptor*>((&((mValue).VSurfaceDescriptor)));
875 : }
876 : const SurfaceDescriptor* const
877 0 : constptr_SurfaceDescriptor() const
878 : {
879 0 : return reinterpret_cast<const SurfaceDescriptor* const>((&((mValue).VSurfaceDescriptor)));
880 : }
881 : YUVImage*
882 0 : ptr_YUVImage()
883 : {
884 0 : return reinterpret_cast<YUVImage*>((&((mValue).VYUVImage)));
885 : }
886 : const YUVImage* const
887 0 : constptr_YUVImage() const
888 : {
889 0 : return reinterpret_cast<const YUVImage* const>((&((mValue).VYUVImage)));
890 : }
891 : null_t*
892 0 : ptr_null_t()
893 : {
894 0 : return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
895 : }
896 : const null_t* const
897 0 : constptr_null_t() const
898 : {
899 0 : return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
900 : }
901 :
902 : bool
903 : MaybeDestroy(Type aNewType);
904 :
905 : void
906 0 : AssertSanity() const
907 : {
908 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
909 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
910 0 : }
911 : void
912 0 : AssertSanity(Type aType) const
913 : {
914 0 : AssertSanity();
915 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
916 0 : }
917 :
918 : public:
919 0 : SharedImage() :
920 0 : mType(T__None)
921 : {
922 0 : }
923 :
924 : SharedImage(const SurfaceDescriptor& aOther);
925 :
926 : SharedImage(const YUVImage& aOther);
927 :
928 : SharedImage(const null_t& aOther);
929 :
930 : SharedImage(const SharedImage& aOther);
931 :
932 : ~SharedImage();
933 :
934 : Type
935 0 : type() const
936 : {
937 0 : return mType;
938 : }
939 :
940 : SharedImage&
941 : operator=(const SurfaceDescriptor& aRhs);
942 :
943 : SharedImage&
944 : operator=(const YUVImage& aRhs);
945 :
946 : SharedImage&
947 : operator=(const null_t& aRhs);
948 :
949 : SharedImage&
950 : operator=(const SharedImage& aRhs);
951 :
952 : bool
953 : operator==(const SurfaceDescriptor& aRhs) const;
954 :
955 : bool
956 : operator==(const YUVImage& aRhs) const;
957 :
958 : bool
959 : operator==(const null_t& aRhs) const;
960 :
961 : bool
962 : operator==(const SharedImage& aRhs) const;
963 :
964 : SurfaceDescriptor&
965 0 : get_SurfaceDescriptor()
966 : {
967 0 : AssertSanity(TSurfaceDescriptor);
968 0 : return (*(ptr_SurfaceDescriptor()));
969 : }
970 : const SurfaceDescriptor&
971 0 : get_SurfaceDescriptor() const
972 : {
973 0 : AssertSanity(TSurfaceDescriptor);
974 0 : return (*(constptr_SurfaceDescriptor()));
975 : }
976 : operator SurfaceDescriptor&()
977 : {
978 : return get_SurfaceDescriptor();
979 : }
980 0 : operator const SurfaceDescriptor&() const
981 : {
982 0 : return get_SurfaceDescriptor();
983 : }
984 :
985 : YUVImage&
986 0 : get_YUVImage()
987 : {
988 0 : AssertSanity(TYUVImage);
989 0 : return (*(ptr_YUVImage()));
990 : }
991 : const YUVImage&
992 0 : get_YUVImage() const
993 : {
994 0 : AssertSanity(TYUVImage);
995 0 : return (*(constptr_YUVImage()));
996 : }
997 : operator YUVImage&()
998 : {
999 : return get_YUVImage();
1000 : }
1001 : operator const YUVImage&() const
1002 : {
1003 : return get_YUVImage();
1004 : }
1005 :
1006 : null_t&
1007 0 : get_null_t()
1008 : {
1009 0 : AssertSanity(Tnull_t);
1010 0 : return (*(ptr_null_t()));
1011 : }
1012 : const null_t&
1013 0 : get_null_t() const
1014 : {
1015 0 : AssertSanity(Tnull_t);
1016 0 : return (*(constptr_null_t()));
1017 : }
1018 : operator null_t&()
1019 : {
1020 : return get_null_t();
1021 : }
1022 : operator const null_t&() const
1023 : {
1024 : return get_null_t();
1025 : }
1026 :
1027 : private:
1028 : Value mValue;
1029 : Type mType;
1030 : };
1031 : } // namespace layers
1032 : } // namespace mozilla
1033 :
1034 : namespace mozilla {
1035 : namespace layers {
1036 : class SurfaceDescriptor;
1037 : } // namespace layers
1038 : } // namespace mozilla
1039 :
1040 : //-----------------------------------------------------------------------------
1041 : // Declaration of the IPDL type |struct ThebesBuffer|
1042 : //
1043 : namespace mozilla {
1044 : namespace layers {
1045 : class ThebesBuffer MOZ_FINAL
1046 : {
1047 : private:
1048 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
1049 :
1050 : public:
1051 : ThebesBuffer();
1052 :
1053 0 : ThebesBuffer(
1054 : const SurfaceDescriptor& _buffer,
1055 : const nsIntRect& _rect,
1056 : const nsIntPoint& _rotation)
1057 0 : {
1058 0 : Init();
1059 0 : Assign(_buffer, _rect, _rotation);
1060 0 : }
1061 :
1062 0 : ThebesBuffer(const ThebesBuffer& _o)
1063 0 : {
1064 0 : Init();
1065 0 : Assign((_o).buffer(), (_o).rect(), (_o).rotation());
1066 0 : }
1067 :
1068 : ~ThebesBuffer();
1069 :
1070 : void
1071 0 : operator=(const ThebesBuffer& _o)
1072 : {
1073 0 : Assign((_o).buffer(), (_o).rect(), (_o).rotation());
1074 0 : }
1075 :
1076 : bool
1077 : operator==(const ThebesBuffer& _o) const;
1078 :
1079 : SurfaceDescriptor&
1080 0 : buffer()
1081 : {
1082 0 : return buffer_;
1083 : }
1084 : const SurfaceDescriptor&
1085 0 : buffer() const
1086 : {
1087 0 : return buffer_;
1088 : }
1089 :
1090 : nsIntRect&
1091 0 : rect()
1092 : {
1093 0 : return rect_;
1094 : }
1095 : const nsIntRect&
1096 0 : rect() const
1097 : {
1098 0 : return rect_;
1099 : }
1100 :
1101 : nsIntPoint&
1102 0 : rotation()
1103 : {
1104 0 : return rotation_;
1105 : }
1106 : const nsIntPoint&
1107 0 : rotation() const
1108 : {
1109 0 : return rotation_;
1110 : }
1111 :
1112 : private:
1113 : void
1114 : Init();
1115 :
1116 : void
1117 : Assign(
1118 : const SurfaceDescriptor& _buffer,
1119 : const nsIntRect& _rect,
1120 : const nsIntPoint& _rotation);
1121 :
1122 : SurfaceDescriptor buffer_;
1123 : nsIntRect rect_;
1124 : nsIntPoint rotation_;
1125 : };
1126 : } // namespace layers
1127 : } // namespace mozilla
1128 :
1129 : namespace mozilla {
1130 : namespace layers {
1131 : class ThebesBuffer;
1132 : } // namespace layers
1133 : } // namespace mozilla
1134 :
1135 : //-----------------------------------------------------------------------------
1136 : // Declaration of the IPDL type |union OptionalThebesBuffer|
1137 : //
1138 : namespace mozilla {
1139 : namespace layers {
1140 : class OptionalThebesBuffer MOZ_FINAL
1141 : {
1142 : public:
1143 : enum Type {
1144 : T__None,
1145 : TThebesBuffer = 1,
1146 : Tnull_t,
1147 : T__Last = Tnull_t
1148 : };
1149 :
1150 : private:
1151 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
1152 : typedef mozilla::null_t null_t;
1153 : typedef ThebesBuffer ThebesBuffer__tdef;
1154 : typedef null_t null_t__tdef;
1155 :
1156 : union Value {
1157 : char VThebesBuffer[sizeof(ThebesBuffer)];
1158 : char Vnull_t[sizeof(null_t)];
1159 : };
1160 :
1161 : ThebesBuffer*
1162 0 : ptr_ThebesBuffer()
1163 : {
1164 0 : return reinterpret_cast<ThebesBuffer*>((&((mValue).VThebesBuffer)));
1165 : }
1166 : const ThebesBuffer* const
1167 0 : constptr_ThebesBuffer() const
1168 : {
1169 0 : return reinterpret_cast<const ThebesBuffer* const>((&((mValue).VThebesBuffer)));
1170 : }
1171 : null_t*
1172 0 : ptr_null_t()
1173 : {
1174 0 : return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
1175 : }
1176 : const null_t* const
1177 0 : constptr_null_t() const
1178 : {
1179 0 : return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
1180 : }
1181 :
1182 : bool
1183 : MaybeDestroy(Type aNewType);
1184 :
1185 : void
1186 0 : AssertSanity() const
1187 : {
1188 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
1189 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
1190 0 : }
1191 : void
1192 0 : AssertSanity(Type aType) const
1193 : {
1194 0 : AssertSanity();
1195 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
1196 0 : }
1197 :
1198 : public:
1199 0 : OptionalThebesBuffer() :
1200 0 : mType(T__None)
1201 : {
1202 0 : }
1203 :
1204 : OptionalThebesBuffer(const ThebesBuffer& aOther);
1205 :
1206 : OptionalThebesBuffer(const null_t& aOther);
1207 :
1208 : OptionalThebesBuffer(const OptionalThebesBuffer& aOther);
1209 :
1210 : ~OptionalThebesBuffer();
1211 :
1212 : Type
1213 0 : type() const
1214 : {
1215 0 : return mType;
1216 : }
1217 :
1218 : OptionalThebesBuffer&
1219 : operator=(const ThebesBuffer& aRhs);
1220 :
1221 : OptionalThebesBuffer&
1222 : operator=(const null_t& aRhs);
1223 :
1224 : OptionalThebesBuffer&
1225 : operator=(const OptionalThebesBuffer& aRhs);
1226 :
1227 : bool
1228 : operator==(const ThebesBuffer& aRhs) const;
1229 :
1230 : bool
1231 : operator==(const null_t& aRhs) const;
1232 :
1233 : bool
1234 : operator==(const OptionalThebesBuffer& aRhs) const;
1235 :
1236 : ThebesBuffer&
1237 0 : get_ThebesBuffer()
1238 : {
1239 0 : AssertSanity(TThebesBuffer);
1240 0 : return (*(ptr_ThebesBuffer()));
1241 : }
1242 : const ThebesBuffer&
1243 0 : get_ThebesBuffer() const
1244 : {
1245 0 : AssertSanity(TThebesBuffer);
1246 0 : return (*(constptr_ThebesBuffer()));
1247 : }
1248 : operator ThebesBuffer&()
1249 : {
1250 : return get_ThebesBuffer();
1251 : }
1252 : operator const ThebesBuffer&() const
1253 : {
1254 : return get_ThebesBuffer();
1255 : }
1256 :
1257 : null_t&
1258 0 : get_null_t()
1259 : {
1260 0 : AssertSanity(Tnull_t);
1261 0 : return (*(ptr_null_t()));
1262 : }
1263 : const null_t&
1264 0 : get_null_t() const
1265 : {
1266 0 : AssertSanity(Tnull_t);
1267 0 : return (*(constptr_null_t()));
1268 : }
1269 : operator null_t&()
1270 : {
1271 : return get_null_t();
1272 : }
1273 : operator const null_t&() const
1274 : {
1275 : return get_null_t();
1276 : }
1277 :
1278 : private:
1279 : Value mValue;
1280 : Type mType;
1281 : };
1282 : } // namespace layers
1283 : } // namespace mozilla
1284 :
1285 : namespace mozilla {
1286 : namespace layers {
1287 : class SurfaceDescriptor;
1288 : } // namespace layers
1289 : } // namespace mozilla
1290 :
1291 : //-----------------------------------------------------------------------------
1292 : // Declaration of the IPDL type |union CanvasSurface|
1293 : //
1294 : namespace mozilla {
1295 : namespace layers {
1296 : class CanvasSurface MOZ_FINAL
1297 : {
1298 : public:
1299 : enum Type {
1300 : T__None,
1301 : TSurfaceDescriptor = 1,
1302 : Tnull_t,
1303 : T__Last = Tnull_t
1304 : };
1305 :
1306 : private:
1307 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
1308 : typedef mozilla::null_t null_t;
1309 : typedef SurfaceDescriptor SurfaceDescriptor__tdef;
1310 : typedef null_t null_t__tdef;
1311 :
1312 : union Value {
1313 : char VSurfaceDescriptor[sizeof(SurfaceDescriptor)];
1314 : char Vnull_t[sizeof(null_t)];
1315 : };
1316 :
1317 : SurfaceDescriptor*
1318 0 : ptr_SurfaceDescriptor()
1319 : {
1320 0 : return reinterpret_cast<SurfaceDescriptor*>((&((mValue).VSurfaceDescriptor)));
1321 : }
1322 : const SurfaceDescriptor* const
1323 0 : constptr_SurfaceDescriptor() const
1324 : {
1325 0 : return reinterpret_cast<const SurfaceDescriptor* const>((&((mValue).VSurfaceDescriptor)));
1326 : }
1327 : null_t*
1328 0 : ptr_null_t()
1329 : {
1330 0 : return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
1331 : }
1332 : const null_t* const
1333 0 : constptr_null_t() const
1334 : {
1335 0 : return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
1336 : }
1337 :
1338 : bool
1339 : MaybeDestroy(Type aNewType);
1340 :
1341 : void
1342 0 : AssertSanity() const
1343 : {
1344 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
1345 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
1346 0 : }
1347 : void
1348 0 : AssertSanity(Type aType) const
1349 : {
1350 0 : AssertSanity();
1351 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
1352 0 : }
1353 :
1354 : public:
1355 0 : CanvasSurface() :
1356 0 : mType(T__None)
1357 : {
1358 0 : }
1359 :
1360 : CanvasSurface(const SurfaceDescriptor& aOther);
1361 :
1362 : CanvasSurface(const null_t& aOther);
1363 :
1364 : CanvasSurface(const CanvasSurface& aOther);
1365 :
1366 : ~CanvasSurface();
1367 :
1368 : Type
1369 0 : type() const
1370 : {
1371 0 : return mType;
1372 : }
1373 :
1374 : CanvasSurface&
1375 : operator=(const SurfaceDescriptor& aRhs);
1376 :
1377 : CanvasSurface&
1378 : operator=(const null_t& aRhs);
1379 :
1380 : CanvasSurface&
1381 : operator=(const CanvasSurface& aRhs);
1382 :
1383 : bool
1384 : operator==(const SurfaceDescriptor& aRhs) const;
1385 :
1386 : bool
1387 : operator==(const null_t& aRhs) const;
1388 :
1389 : bool
1390 : operator==(const CanvasSurface& aRhs) const;
1391 :
1392 : SurfaceDescriptor&
1393 0 : get_SurfaceDescriptor()
1394 : {
1395 0 : AssertSanity(TSurfaceDescriptor);
1396 0 : return (*(ptr_SurfaceDescriptor()));
1397 : }
1398 : const SurfaceDescriptor&
1399 0 : get_SurfaceDescriptor() const
1400 : {
1401 0 : AssertSanity(TSurfaceDescriptor);
1402 0 : return (*(constptr_SurfaceDescriptor()));
1403 : }
1404 : operator SurfaceDescriptor&()
1405 : {
1406 : return get_SurfaceDescriptor();
1407 : }
1408 0 : operator const SurfaceDescriptor&() const
1409 : {
1410 0 : return get_SurfaceDescriptor();
1411 : }
1412 :
1413 : null_t&
1414 0 : get_null_t()
1415 : {
1416 0 : AssertSanity(Tnull_t);
1417 0 : return (*(ptr_null_t()));
1418 : }
1419 : const null_t&
1420 0 : get_null_t() const
1421 : {
1422 0 : AssertSanity(Tnull_t);
1423 0 : return (*(constptr_null_t()));
1424 : }
1425 : operator null_t&()
1426 : {
1427 : return get_null_t();
1428 : }
1429 : operator const null_t&() const
1430 : {
1431 : return get_null_t();
1432 : }
1433 :
1434 : private:
1435 : Value mValue;
1436 : Type mType;
1437 : };
1438 : } // namespace layers
1439 : } // namespace mozilla
1440 :
1441 :
1442 : //-----------------------------------------------------------------------------
1443 : // Declaration of the IPDL type |struct CommonLayerAttributes|
1444 : //
1445 : namespace mozilla {
1446 : namespace layers {
1447 : class CommonLayerAttributes MOZ_FINAL
1448 : {
1449 : private:
1450 :
1451 : public:
1452 : CommonLayerAttributes();
1453 :
1454 : CommonLayerAttributes(
1455 : const nsIntRegion& _visibleRegion,
1456 : const gfx3DMatrix& _transform,
1457 : const PRUint32& _contentFlags,
1458 : const float& _opacity,
1459 : const bool& _useClipRect,
1460 : const nsIntRect& _clipRect,
1461 : const bool& _useTileSourceRect,
1462 : const nsIntRect& _tileSourceRect,
1463 : const bool& _isFixedPosition)
1464 : {
1465 : Init();
1466 : Assign(_visibleRegion, _transform, _contentFlags, _opacity, _useClipRect, _clipRect, _useTileSourceRect, _tileSourceRect, _isFixedPosition);
1467 : }
1468 :
1469 : CommonLayerAttributes(const CommonLayerAttributes& _o)
1470 : {
1471 : Init();
1472 : Assign((_o).visibleRegion(), (_o).transform(), (_o).contentFlags(), (_o).opacity(), (_o).useClipRect(), (_o).clipRect(), (_o).useTileSourceRect(), (_o).tileSourceRect(), (_o).isFixedPosition());
1473 : }
1474 :
1475 : ~CommonLayerAttributes();
1476 :
1477 : void
1478 0 : operator=(const CommonLayerAttributes& _o)
1479 : {
1480 0 : Assign((_o).visibleRegion(), (_o).transform(), (_o).contentFlags(), (_o).opacity(), (_o).useClipRect(), (_o).clipRect(), (_o).useTileSourceRect(), (_o).tileSourceRect(), (_o).isFixedPosition());
1481 0 : }
1482 :
1483 : bool
1484 : operator==(const CommonLayerAttributes& _o) const;
1485 :
1486 : nsIntRegion&
1487 0 : visibleRegion()
1488 : {
1489 0 : return visibleRegion_;
1490 : }
1491 : const nsIntRegion&
1492 0 : visibleRegion() const
1493 : {
1494 0 : return visibleRegion_;
1495 : }
1496 :
1497 : gfx3DMatrix&
1498 0 : transform()
1499 : {
1500 0 : return transform_;
1501 : }
1502 : const gfx3DMatrix&
1503 0 : transform() const
1504 : {
1505 0 : return transform_;
1506 : }
1507 :
1508 : PRUint32&
1509 0 : contentFlags()
1510 : {
1511 0 : return contentFlags_;
1512 : }
1513 : const PRUint32&
1514 0 : contentFlags() const
1515 : {
1516 0 : return contentFlags_;
1517 : }
1518 :
1519 : float&
1520 0 : opacity()
1521 : {
1522 0 : return opacity_;
1523 : }
1524 : const float&
1525 0 : opacity() const
1526 : {
1527 0 : return opacity_;
1528 : }
1529 :
1530 : bool&
1531 0 : useClipRect()
1532 : {
1533 0 : return useClipRect_;
1534 : }
1535 : const bool&
1536 0 : useClipRect() const
1537 : {
1538 0 : return useClipRect_;
1539 : }
1540 :
1541 : nsIntRect&
1542 0 : clipRect()
1543 : {
1544 0 : return clipRect_;
1545 : }
1546 : const nsIntRect&
1547 0 : clipRect() const
1548 : {
1549 0 : return clipRect_;
1550 : }
1551 :
1552 : bool&
1553 0 : useTileSourceRect()
1554 : {
1555 0 : return useTileSourceRect_;
1556 : }
1557 : const bool&
1558 0 : useTileSourceRect() const
1559 : {
1560 0 : return useTileSourceRect_;
1561 : }
1562 :
1563 : nsIntRect&
1564 0 : tileSourceRect()
1565 : {
1566 0 : return tileSourceRect_;
1567 : }
1568 : const nsIntRect&
1569 0 : tileSourceRect() const
1570 : {
1571 0 : return tileSourceRect_;
1572 : }
1573 :
1574 : bool&
1575 0 : isFixedPosition()
1576 : {
1577 0 : return isFixedPosition_;
1578 : }
1579 : const bool&
1580 0 : isFixedPosition() const
1581 : {
1582 0 : return isFixedPosition_;
1583 : }
1584 :
1585 : private:
1586 : void
1587 : Init();
1588 :
1589 : void
1590 : Assign(
1591 : const nsIntRegion& _visibleRegion,
1592 : const gfx3DMatrix& _transform,
1593 : const PRUint32& _contentFlags,
1594 : const float& _opacity,
1595 : const bool& _useClipRect,
1596 : const nsIntRect& _clipRect,
1597 : const bool& _useTileSourceRect,
1598 : const nsIntRect& _tileSourceRect,
1599 : const bool& _isFixedPosition);
1600 :
1601 : nsIntRegion visibleRegion_;
1602 : gfx3DMatrix transform_;
1603 : PRUint32 contentFlags_;
1604 : float opacity_;
1605 : bool useClipRect_;
1606 : nsIntRect clipRect_;
1607 : bool useTileSourceRect_;
1608 : nsIntRect tileSourceRect_;
1609 : bool isFixedPosition_;
1610 : };
1611 : } // namespace layers
1612 : } // namespace mozilla
1613 :
1614 :
1615 : //-----------------------------------------------------------------------------
1616 : // Declaration of the IPDL type |struct ThebesLayerAttributes|
1617 : //
1618 : namespace mozilla {
1619 : namespace layers {
1620 : class ThebesLayerAttributes MOZ_FINAL
1621 : {
1622 : private:
1623 :
1624 : public:
1625 : ThebesLayerAttributes();
1626 :
1627 0 : ThebesLayerAttributes(const nsIntRegion& _validRegion)
1628 0 : {
1629 0 : Init();
1630 0 : Assign(_validRegion);
1631 0 : }
1632 :
1633 0 : ThebesLayerAttributes(const ThebesLayerAttributes& _o)
1634 0 : {
1635 0 : Init();
1636 0 : Assign((_o).validRegion());
1637 0 : }
1638 :
1639 : ~ThebesLayerAttributes();
1640 :
1641 : void
1642 0 : operator=(const ThebesLayerAttributes& _o)
1643 : {
1644 0 : Assign((_o).validRegion());
1645 0 : }
1646 :
1647 : bool
1648 : operator==(const ThebesLayerAttributes& _o) const;
1649 :
1650 : nsIntRegion&
1651 0 : validRegion()
1652 : {
1653 0 : return validRegion_;
1654 : }
1655 : const nsIntRegion&
1656 0 : validRegion() const
1657 : {
1658 0 : return validRegion_;
1659 : }
1660 :
1661 : private:
1662 : void
1663 : Init();
1664 :
1665 : void
1666 : Assign(const nsIntRegion& _validRegion);
1667 :
1668 : nsIntRegion validRegion_;
1669 : };
1670 : } // namespace layers
1671 : } // namespace mozilla
1672 :
1673 :
1674 : //-----------------------------------------------------------------------------
1675 : // Declaration of the IPDL type |struct ContainerLayerAttributes|
1676 : //
1677 : namespace mozilla {
1678 : namespace layers {
1679 : class ContainerLayerAttributes MOZ_FINAL
1680 : {
1681 : private:
1682 : typedef mozilla::layers::FrameMetrics FrameMetrics;
1683 :
1684 : public:
1685 : ContainerLayerAttributes();
1686 :
1687 0 : ContainerLayerAttributes(const FrameMetrics& _metrics)
1688 0 : {
1689 0 : Init();
1690 0 : Assign(_metrics);
1691 0 : }
1692 :
1693 0 : ContainerLayerAttributes(const ContainerLayerAttributes& _o)
1694 0 : {
1695 0 : Init();
1696 0 : Assign((_o).metrics());
1697 0 : }
1698 :
1699 : ~ContainerLayerAttributes();
1700 :
1701 : void
1702 0 : operator=(const ContainerLayerAttributes& _o)
1703 : {
1704 0 : Assign((_o).metrics());
1705 0 : }
1706 :
1707 : bool
1708 : operator==(const ContainerLayerAttributes& _o) const;
1709 :
1710 : FrameMetrics&
1711 0 : metrics()
1712 : {
1713 0 : return metrics_;
1714 : }
1715 : const FrameMetrics&
1716 0 : metrics() const
1717 : {
1718 0 : return metrics_;
1719 : }
1720 :
1721 : private:
1722 : void
1723 : Init();
1724 :
1725 : void
1726 : Assign(const FrameMetrics& _metrics);
1727 :
1728 : FrameMetrics metrics_;
1729 : };
1730 : } // namespace layers
1731 : } // namespace mozilla
1732 :
1733 :
1734 : //-----------------------------------------------------------------------------
1735 : // Declaration of the IPDL type |struct ColorLayerAttributes|
1736 : //
1737 : namespace mozilla {
1738 : namespace layers {
1739 : class ColorLayerAttributes MOZ_FINAL
1740 : {
1741 : private:
1742 :
1743 : public:
1744 : ColorLayerAttributes();
1745 :
1746 0 : ColorLayerAttributes(const gfxRGBA& _color)
1747 0 : {
1748 0 : Init();
1749 0 : Assign(_color);
1750 0 : }
1751 :
1752 0 : ColorLayerAttributes(const ColorLayerAttributes& _o)
1753 0 : {
1754 0 : Init();
1755 0 : Assign((_o).color());
1756 0 : }
1757 :
1758 : ~ColorLayerAttributes();
1759 :
1760 : void
1761 0 : operator=(const ColorLayerAttributes& _o)
1762 : {
1763 0 : Assign((_o).color());
1764 0 : }
1765 :
1766 : bool
1767 : operator==(const ColorLayerAttributes& _o) const;
1768 :
1769 : gfxRGBA&
1770 0 : color()
1771 : {
1772 0 : return color_;
1773 : }
1774 : const gfxRGBA&
1775 0 : color() const
1776 : {
1777 0 : return color_;
1778 : }
1779 :
1780 : private:
1781 : void
1782 : Init();
1783 :
1784 : void
1785 : Assign(const gfxRGBA& _color);
1786 :
1787 : gfxRGBA color_;
1788 : };
1789 : } // namespace layers
1790 : } // namespace mozilla
1791 :
1792 :
1793 : //-----------------------------------------------------------------------------
1794 : // Declaration of the IPDL type |struct CanvasLayerAttributes|
1795 : //
1796 : namespace mozilla {
1797 : namespace layers {
1798 : class CanvasLayerAttributes MOZ_FINAL
1799 : {
1800 : private:
1801 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
1802 :
1803 : public:
1804 : CanvasLayerAttributes();
1805 :
1806 0 : CanvasLayerAttributes(const GraphicsFilterType& _filter)
1807 : {
1808 0 : Init();
1809 0 : Assign(_filter);
1810 0 : }
1811 :
1812 0 : CanvasLayerAttributes(const CanvasLayerAttributes& _o)
1813 : {
1814 0 : Init();
1815 0 : Assign((_o).filter());
1816 0 : }
1817 :
1818 : ~CanvasLayerAttributes();
1819 :
1820 : void
1821 0 : operator=(const CanvasLayerAttributes& _o)
1822 : {
1823 0 : Assign((_o).filter());
1824 0 : }
1825 :
1826 : bool
1827 : operator==(const CanvasLayerAttributes& _o) const;
1828 :
1829 : GraphicsFilterType&
1830 0 : filter()
1831 : {
1832 0 : return filter_;
1833 : }
1834 : const GraphicsFilterType&
1835 0 : filter() const
1836 : {
1837 0 : return filter_;
1838 : }
1839 :
1840 : private:
1841 : void
1842 : Init();
1843 :
1844 : void
1845 : Assign(const GraphicsFilterType& _filter);
1846 :
1847 : GraphicsFilterType filter_;
1848 : };
1849 : } // namespace layers
1850 : } // namespace mozilla
1851 :
1852 :
1853 : //-----------------------------------------------------------------------------
1854 : // Declaration of the IPDL type |struct ImageLayerAttributes|
1855 : //
1856 : namespace mozilla {
1857 : namespace layers {
1858 : class ImageLayerAttributes MOZ_FINAL
1859 : {
1860 : private:
1861 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
1862 :
1863 : public:
1864 : ImageLayerAttributes();
1865 :
1866 0 : ImageLayerAttributes(const GraphicsFilterType& _filter)
1867 : {
1868 0 : Init();
1869 0 : Assign(_filter);
1870 0 : }
1871 :
1872 0 : ImageLayerAttributes(const ImageLayerAttributes& _o)
1873 : {
1874 0 : Init();
1875 0 : Assign((_o).filter());
1876 0 : }
1877 :
1878 : ~ImageLayerAttributes();
1879 :
1880 : void
1881 0 : operator=(const ImageLayerAttributes& _o)
1882 : {
1883 0 : Assign((_o).filter());
1884 0 : }
1885 :
1886 : bool
1887 : operator==(const ImageLayerAttributes& _o) const;
1888 :
1889 : GraphicsFilterType&
1890 0 : filter()
1891 : {
1892 0 : return filter_;
1893 : }
1894 : const GraphicsFilterType&
1895 0 : filter() const
1896 : {
1897 0 : return filter_;
1898 : }
1899 :
1900 : private:
1901 : void
1902 : Init();
1903 :
1904 : void
1905 : Assign(const GraphicsFilterType& _filter);
1906 :
1907 : GraphicsFilterType filter_;
1908 : };
1909 : } // namespace layers
1910 : } // namespace mozilla
1911 :
1912 : namespace mozilla {
1913 : namespace layers {
1914 : class ThebesLayerAttributes;
1915 : } // namespace layers
1916 : } // namespace mozilla
1917 : namespace mozilla {
1918 : namespace layers {
1919 : class ContainerLayerAttributes;
1920 : } // namespace layers
1921 : } // namespace mozilla
1922 : namespace mozilla {
1923 : namespace layers {
1924 : class ColorLayerAttributes;
1925 : } // namespace layers
1926 : } // namespace mozilla
1927 : namespace mozilla {
1928 : namespace layers {
1929 : class CanvasLayerAttributes;
1930 : } // namespace layers
1931 : } // namespace mozilla
1932 : namespace mozilla {
1933 : namespace layers {
1934 : class ImageLayerAttributes;
1935 : } // namespace layers
1936 : } // namespace mozilla
1937 :
1938 : //-----------------------------------------------------------------------------
1939 : // Declaration of the IPDL type |union SpecificLayerAttributes|
1940 : //
1941 : namespace mozilla {
1942 : namespace layers {
1943 : class SpecificLayerAttributes MOZ_FINAL
1944 : {
1945 : public:
1946 : enum Type {
1947 : T__None,
1948 : Tnull_t = 1,
1949 : TThebesLayerAttributes,
1950 : TContainerLayerAttributes,
1951 : TColorLayerAttributes,
1952 : TCanvasLayerAttributes,
1953 : TImageLayerAttributes,
1954 : T__Last = TImageLayerAttributes
1955 : };
1956 :
1957 : private:
1958 : typedef mozilla::null_t null_t;
1959 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
1960 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
1961 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
1962 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
1963 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
1964 : typedef null_t null_t__tdef;
1965 : typedef ThebesLayerAttributes ThebesLayerAttributes__tdef;
1966 : typedef ContainerLayerAttributes ContainerLayerAttributes__tdef;
1967 : typedef ColorLayerAttributes ColorLayerAttributes__tdef;
1968 : typedef CanvasLayerAttributes CanvasLayerAttributes__tdef;
1969 : typedef ImageLayerAttributes ImageLayerAttributes__tdef;
1970 :
1971 : union Value {
1972 : char Vnull_t[sizeof(null_t)];
1973 : char VThebesLayerAttributes[sizeof(ThebesLayerAttributes)];
1974 : char VContainerLayerAttributes[sizeof(ContainerLayerAttributes)];
1975 : char VColorLayerAttributes[sizeof(ColorLayerAttributes)];
1976 : char VCanvasLayerAttributes[sizeof(CanvasLayerAttributes)];
1977 : char VImageLayerAttributes[sizeof(ImageLayerAttributes)];
1978 : };
1979 :
1980 : null_t*
1981 0 : ptr_null_t()
1982 : {
1983 0 : return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
1984 : }
1985 : const null_t* const
1986 0 : constptr_null_t() const
1987 : {
1988 0 : return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
1989 : }
1990 : ThebesLayerAttributes*
1991 0 : ptr_ThebesLayerAttributes()
1992 : {
1993 0 : return reinterpret_cast<ThebesLayerAttributes*>((&((mValue).VThebesLayerAttributes)));
1994 : }
1995 : const ThebesLayerAttributes* const
1996 0 : constptr_ThebesLayerAttributes() const
1997 : {
1998 0 : return reinterpret_cast<const ThebesLayerAttributes* const>((&((mValue).VThebesLayerAttributes)));
1999 : }
2000 : ContainerLayerAttributes*
2001 0 : ptr_ContainerLayerAttributes()
2002 : {
2003 0 : return reinterpret_cast<ContainerLayerAttributes*>((&((mValue).VContainerLayerAttributes)));
2004 : }
2005 : const ContainerLayerAttributes* const
2006 0 : constptr_ContainerLayerAttributes() const
2007 : {
2008 0 : return reinterpret_cast<const ContainerLayerAttributes* const>((&((mValue).VContainerLayerAttributes)));
2009 : }
2010 : ColorLayerAttributes*
2011 0 : ptr_ColorLayerAttributes()
2012 : {
2013 0 : return reinterpret_cast<ColorLayerAttributes*>((&((mValue).VColorLayerAttributes)));
2014 : }
2015 : const ColorLayerAttributes* const
2016 0 : constptr_ColorLayerAttributes() const
2017 : {
2018 0 : return reinterpret_cast<const ColorLayerAttributes* const>((&((mValue).VColorLayerAttributes)));
2019 : }
2020 : CanvasLayerAttributes*
2021 0 : ptr_CanvasLayerAttributes()
2022 : {
2023 0 : return reinterpret_cast<CanvasLayerAttributes*>((&((mValue).VCanvasLayerAttributes)));
2024 : }
2025 : const CanvasLayerAttributes* const
2026 0 : constptr_CanvasLayerAttributes() const
2027 : {
2028 0 : return reinterpret_cast<const CanvasLayerAttributes* const>((&((mValue).VCanvasLayerAttributes)));
2029 : }
2030 : ImageLayerAttributes*
2031 0 : ptr_ImageLayerAttributes()
2032 : {
2033 0 : return reinterpret_cast<ImageLayerAttributes*>((&((mValue).VImageLayerAttributes)));
2034 : }
2035 : const ImageLayerAttributes* const
2036 0 : constptr_ImageLayerAttributes() const
2037 : {
2038 0 : return reinterpret_cast<const ImageLayerAttributes* const>((&((mValue).VImageLayerAttributes)));
2039 : }
2040 :
2041 : bool
2042 : MaybeDestroy(Type aNewType);
2043 :
2044 : void
2045 0 : AssertSanity() const
2046 : {
2047 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
2048 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
2049 0 : }
2050 : void
2051 0 : AssertSanity(Type aType) const
2052 : {
2053 0 : AssertSanity();
2054 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
2055 0 : }
2056 :
2057 : public:
2058 0 : SpecificLayerAttributes() :
2059 0 : mType(T__None)
2060 : {
2061 0 : }
2062 :
2063 : SpecificLayerAttributes(const null_t& aOther);
2064 :
2065 : SpecificLayerAttributes(const ThebesLayerAttributes& aOther);
2066 :
2067 : SpecificLayerAttributes(const ContainerLayerAttributes& aOther);
2068 :
2069 : SpecificLayerAttributes(const ColorLayerAttributes& aOther);
2070 :
2071 : SpecificLayerAttributes(const CanvasLayerAttributes& aOther);
2072 :
2073 : SpecificLayerAttributes(const ImageLayerAttributes& aOther);
2074 :
2075 : SpecificLayerAttributes(const SpecificLayerAttributes& aOther);
2076 :
2077 : ~SpecificLayerAttributes();
2078 :
2079 : Type
2080 0 : type() const
2081 : {
2082 0 : return mType;
2083 : }
2084 :
2085 : SpecificLayerAttributes&
2086 : operator=(const null_t& aRhs);
2087 :
2088 : SpecificLayerAttributes&
2089 : operator=(const ThebesLayerAttributes& aRhs);
2090 :
2091 : SpecificLayerAttributes&
2092 : operator=(const ContainerLayerAttributes& aRhs);
2093 :
2094 : SpecificLayerAttributes&
2095 : operator=(const ColorLayerAttributes& aRhs);
2096 :
2097 : SpecificLayerAttributes&
2098 : operator=(const CanvasLayerAttributes& aRhs);
2099 :
2100 : SpecificLayerAttributes&
2101 : operator=(const ImageLayerAttributes& aRhs);
2102 :
2103 : SpecificLayerAttributes&
2104 : operator=(const SpecificLayerAttributes& aRhs);
2105 :
2106 : bool
2107 : operator==(const null_t& aRhs) const;
2108 :
2109 : bool
2110 : operator==(const ThebesLayerAttributes& aRhs) const;
2111 :
2112 : bool
2113 : operator==(const ContainerLayerAttributes& aRhs) const;
2114 :
2115 : bool
2116 : operator==(const ColorLayerAttributes& aRhs) const;
2117 :
2118 : bool
2119 : operator==(const CanvasLayerAttributes& aRhs) const;
2120 :
2121 : bool
2122 : operator==(const ImageLayerAttributes& aRhs) const;
2123 :
2124 : bool
2125 : operator==(const SpecificLayerAttributes& aRhs) const;
2126 :
2127 : null_t&
2128 0 : get_null_t()
2129 : {
2130 0 : AssertSanity(Tnull_t);
2131 0 : return (*(ptr_null_t()));
2132 : }
2133 : const null_t&
2134 0 : get_null_t() const
2135 : {
2136 0 : AssertSanity(Tnull_t);
2137 0 : return (*(constptr_null_t()));
2138 : }
2139 : operator null_t&()
2140 : {
2141 : return get_null_t();
2142 : }
2143 : operator const null_t&() const
2144 : {
2145 : return get_null_t();
2146 : }
2147 :
2148 : ThebesLayerAttributes&
2149 0 : get_ThebesLayerAttributes()
2150 : {
2151 0 : AssertSanity(TThebesLayerAttributes);
2152 0 : return (*(ptr_ThebesLayerAttributes()));
2153 : }
2154 : const ThebesLayerAttributes&
2155 0 : get_ThebesLayerAttributes() const
2156 : {
2157 0 : AssertSanity(TThebesLayerAttributes);
2158 0 : return (*(constptr_ThebesLayerAttributes()));
2159 : }
2160 : operator ThebesLayerAttributes&()
2161 : {
2162 : return get_ThebesLayerAttributes();
2163 : }
2164 : operator const ThebesLayerAttributes&() const
2165 : {
2166 : return get_ThebesLayerAttributes();
2167 : }
2168 :
2169 : ContainerLayerAttributes&
2170 0 : get_ContainerLayerAttributes()
2171 : {
2172 0 : AssertSanity(TContainerLayerAttributes);
2173 0 : return (*(ptr_ContainerLayerAttributes()));
2174 : }
2175 : const ContainerLayerAttributes&
2176 0 : get_ContainerLayerAttributes() const
2177 : {
2178 0 : AssertSanity(TContainerLayerAttributes);
2179 0 : return (*(constptr_ContainerLayerAttributes()));
2180 : }
2181 : operator ContainerLayerAttributes&()
2182 : {
2183 : return get_ContainerLayerAttributes();
2184 : }
2185 : operator const ContainerLayerAttributes&() const
2186 : {
2187 : return get_ContainerLayerAttributes();
2188 : }
2189 :
2190 : ColorLayerAttributes&
2191 0 : get_ColorLayerAttributes()
2192 : {
2193 0 : AssertSanity(TColorLayerAttributes);
2194 0 : return (*(ptr_ColorLayerAttributes()));
2195 : }
2196 : const ColorLayerAttributes&
2197 0 : get_ColorLayerAttributes() const
2198 : {
2199 0 : AssertSanity(TColorLayerAttributes);
2200 0 : return (*(constptr_ColorLayerAttributes()));
2201 : }
2202 : operator ColorLayerAttributes&()
2203 : {
2204 : return get_ColorLayerAttributes();
2205 : }
2206 : operator const ColorLayerAttributes&() const
2207 : {
2208 : return get_ColorLayerAttributes();
2209 : }
2210 :
2211 : CanvasLayerAttributes&
2212 0 : get_CanvasLayerAttributes()
2213 : {
2214 0 : AssertSanity(TCanvasLayerAttributes);
2215 0 : return (*(ptr_CanvasLayerAttributes()));
2216 : }
2217 : const CanvasLayerAttributes&
2218 0 : get_CanvasLayerAttributes() const
2219 : {
2220 0 : AssertSanity(TCanvasLayerAttributes);
2221 0 : return (*(constptr_CanvasLayerAttributes()));
2222 : }
2223 : operator CanvasLayerAttributes&()
2224 : {
2225 : return get_CanvasLayerAttributes();
2226 : }
2227 : operator const CanvasLayerAttributes&() const
2228 : {
2229 : return get_CanvasLayerAttributes();
2230 : }
2231 :
2232 : ImageLayerAttributes&
2233 0 : get_ImageLayerAttributes()
2234 : {
2235 0 : AssertSanity(TImageLayerAttributes);
2236 0 : return (*(ptr_ImageLayerAttributes()));
2237 : }
2238 : const ImageLayerAttributes&
2239 0 : get_ImageLayerAttributes() const
2240 : {
2241 0 : AssertSanity(TImageLayerAttributes);
2242 0 : return (*(constptr_ImageLayerAttributes()));
2243 : }
2244 : operator ImageLayerAttributes&()
2245 : {
2246 : return get_ImageLayerAttributes();
2247 : }
2248 : operator const ImageLayerAttributes&() const
2249 : {
2250 : return get_ImageLayerAttributes();
2251 : }
2252 :
2253 : private:
2254 : Value mValue;
2255 : Type mType;
2256 : };
2257 : } // namespace layers
2258 : } // namespace mozilla
2259 :
2260 : namespace mozilla {
2261 : namespace layers {
2262 : class CommonLayerAttributes;
2263 : } // namespace layers
2264 : } // namespace mozilla
2265 : namespace mozilla {
2266 : namespace layers {
2267 : class SpecificLayerAttributes;
2268 : } // namespace layers
2269 : } // namespace mozilla
2270 :
2271 : //-----------------------------------------------------------------------------
2272 : // Declaration of the IPDL type |struct LayerAttributes|
2273 : //
2274 : namespace mozilla {
2275 : namespace layers {
2276 : class LayerAttributes MOZ_FINAL
2277 : {
2278 : private:
2279 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
2280 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
2281 :
2282 : public:
2283 : LayerAttributes();
2284 :
2285 : LayerAttributes(
2286 : const CommonLayerAttributes& _common,
2287 : const SpecificLayerAttributes& _specific)
2288 : {
2289 : Init();
2290 : Assign(_common, _specific);
2291 : }
2292 :
2293 : LayerAttributes(const LayerAttributes& _o)
2294 : {
2295 : Init();
2296 : Assign((_o).common(), (_o).specific());
2297 : }
2298 :
2299 : ~LayerAttributes();
2300 :
2301 : void
2302 0 : operator=(const LayerAttributes& _o)
2303 : {
2304 0 : Assign((_o).common(), (_o).specific());
2305 0 : }
2306 :
2307 : bool
2308 : operator==(const LayerAttributes& _o) const;
2309 :
2310 : CommonLayerAttributes&
2311 0 : common()
2312 : {
2313 0 : return common_;
2314 : }
2315 : const CommonLayerAttributes&
2316 0 : common() const
2317 : {
2318 0 : return common_;
2319 : }
2320 :
2321 : SpecificLayerAttributes&
2322 0 : specific()
2323 : {
2324 0 : return specific_;
2325 : }
2326 : const SpecificLayerAttributes&
2327 0 : specific() const
2328 : {
2329 0 : return specific_;
2330 : }
2331 :
2332 : private:
2333 : void
2334 : Init();
2335 :
2336 : void
2337 : Assign(
2338 : const CommonLayerAttributes& _common,
2339 : const SpecificLayerAttributes& _specific);
2340 :
2341 : CommonLayerAttributes common_;
2342 : SpecificLayerAttributes specific_;
2343 : };
2344 : } // namespace layers
2345 : } // namespace mozilla
2346 :
2347 : namespace mozilla {
2348 : namespace layers {
2349 : class PLayerParent;
2350 : } // namespace layers
2351 : } // namespace mozilla
2352 :
2353 : namespace mozilla {
2354 : namespace layers {
2355 : class PLayerChild;
2356 : } // namespace layers
2357 : } // namespace mozilla
2358 :
2359 : namespace mozilla {
2360 : namespace layers {
2361 : class LayerAttributes;
2362 : } // namespace layers
2363 : } // namespace mozilla
2364 :
2365 : //-----------------------------------------------------------------------------
2366 : // Declaration of the IPDL type |struct OpSetLayerAttributes|
2367 : //
2368 : namespace mozilla {
2369 : namespace layers {
2370 : class OpSetLayerAttributes MOZ_FINAL
2371 : {
2372 : private:
2373 : typedef mozilla::layers::PLayerParent PLayerParent;
2374 : typedef mozilla::layers::PLayerChild PLayerChild;
2375 : typedef mozilla::layers::LayerAttributes LayerAttributes;
2376 :
2377 : public:
2378 : OpSetLayerAttributes();
2379 :
2380 0 : OpSetLayerAttributes(
2381 : PLayerParent* _layerParent,
2382 : PLayerChild* _layerChild,
2383 : const LayerAttributes& _attrs)
2384 0 : {
2385 0 : Init();
2386 0 : Assign(_layerParent, _layerChild, _attrs);
2387 0 : }
2388 :
2389 0 : OpSetLayerAttributes(const OpSetLayerAttributes& _o)
2390 0 : {
2391 0 : Init();
2392 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).attrs());
2393 0 : }
2394 :
2395 : ~OpSetLayerAttributes();
2396 :
2397 : void
2398 0 : operator=(const OpSetLayerAttributes& _o)
2399 : {
2400 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).attrs());
2401 0 : }
2402 :
2403 : bool
2404 : operator==(const OpSetLayerAttributes& _o) const;
2405 :
2406 : PLayerParent*&
2407 0 : layerParent()
2408 : {
2409 0 : return layerParent_;
2410 : }
2411 : PLayerParent*
2412 0 : layerParent() const
2413 : {
2414 0 : return layerParent_;
2415 : }
2416 :
2417 : PLayerChild*&
2418 0 : layerChild()
2419 : {
2420 0 : return layerChild_;
2421 : }
2422 : PLayerChild*
2423 0 : layerChild() const
2424 : {
2425 0 : return layerChild_;
2426 : }
2427 :
2428 : LayerAttributes&
2429 0 : attrs()
2430 : {
2431 0 : return attrs_;
2432 : }
2433 : const LayerAttributes&
2434 0 : attrs() const
2435 : {
2436 0 : return attrs_;
2437 : }
2438 :
2439 : private:
2440 : void
2441 : Init();
2442 :
2443 : void
2444 : Assign(
2445 : PLayerParent* _layerParent,
2446 : PLayerChild* _layerChild,
2447 : const LayerAttributes& _attrs);
2448 :
2449 : PLayerParent* layerParent_;
2450 : PLayerChild* layerChild_;
2451 : LayerAttributes attrs_;
2452 : };
2453 : } // namespace layers
2454 : } // namespace mozilla
2455 :
2456 : namespace mozilla {
2457 : namespace layers {
2458 : class PLayerParent;
2459 : } // namespace layers
2460 : } // namespace mozilla
2461 :
2462 : namespace mozilla {
2463 : namespace layers {
2464 : class PLayerChild;
2465 : } // namespace layers
2466 : } // namespace mozilla
2467 :
2468 :
2469 : //-----------------------------------------------------------------------------
2470 : // Declaration of the IPDL type |struct OpSetRoot|
2471 : //
2472 : namespace mozilla {
2473 : namespace layers {
2474 : class OpSetRoot MOZ_FINAL
2475 : {
2476 : private:
2477 : typedef mozilla::layers::PLayerParent PLayerParent;
2478 : typedef mozilla::layers::PLayerChild PLayerChild;
2479 :
2480 : public:
2481 : OpSetRoot();
2482 :
2483 0 : OpSetRoot(
2484 : PLayerParent* _rootParent,
2485 : PLayerChild* _rootChild)
2486 : {
2487 0 : Init();
2488 0 : Assign(_rootParent, _rootChild);
2489 0 : }
2490 :
2491 0 : OpSetRoot(const OpSetRoot& _o)
2492 : {
2493 0 : Init();
2494 0 : Assign(const_cast<PLayerParent*>((_o).rootParent()), const_cast<PLayerChild*>((_o).rootChild()));
2495 0 : }
2496 :
2497 : ~OpSetRoot();
2498 :
2499 : void
2500 0 : operator=(const OpSetRoot& _o)
2501 : {
2502 0 : Assign(const_cast<PLayerParent*>((_o).rootParent()), const_cast<PLayerChild*>((_o).rootChild()));
2503 0 : }
2504 :
2505 : bool
2506 : operator==(const OpSetRoot& _o) const;
2507 :
2508 : PLayerParent*&
2509 0 : rootParent()
2510 : {
2511 0 : return rootParent_;
2512 : }
2513 : PLayerParent*
2514 0 : rootParent() const
2515 : {
2516 0 : return rootParent_;
2517 : }
2518 :
2519 : PLayerChild*&
2520 0 : rootChild()
2521 : {
2522 0 : return rootChild_;
2523 : }
2524 : PLayerChild*
2525 0 : rootChild() const
2526 : {
2527 0 : return rootChild_;
2528 : }
2529 :
2530 : private:
2531 : void
2532 : Init();
2533 :
2534 : void
2535 : Assign(
2536 : PLayerParent* _rootParent,
2537 : PLayerChild* _rootChild);
2538 :
2539 : PLayerParent* rootParent_;
2540 : PLayerChild* rootChild_;
2541 : };
2542 : } // namespace layers
2543 : } // namespace mozilla
2544 :
2545 : namespace mozilla {
2546 : namespace layers {
2547 : class PLayerParent;
2548 : } // namespace layers
2549 : } // namespace mozilla
2550 :
2551 : namespace mozilla {
2552 : namespace layers {
2553 : class PLayerChild;
2554 : } // namespace layers
2555 : } // namespace mozilla
2556 :
2557 :
2558 : //-----------------------------------------------------------------------------
2559 : // Declaration of the IPDL type |struct OpInsertAfter|
2560 : //
2561 : namespace mozilla {
2562 : namespace layers {
2563 : class OpInsertAfter MOZ_FINAL
2564 : {
2565 : private:
2566 : typedef mozilla::layers::PLayerParent PLayerParent;
2567 : typedef mozilla::layers::PLayerChild PLayerChild;
2568 :
2569 : public:
2570 : OpInsertAfter();
2571 :
2572 0 : OpInsertAfter(
2573 : PLayerParent* _containerParent,
2574 : PLayerChild* _containerChild,
2575 : PLayerParent* _childLayerParent,
2576 : PLayerChild* _childLayerChild,
2577 : PLayerParent* _afterParent,
2578 : PLayerChild* _afterChild)
2579 : {
2580 0 : Init();
2581 0 : Assign(_containerParent, _containerChild, _childLayerParent, _childLayerChild, _afterParent, _afterChild);
2582 0 : }
2583 :
2584 0 : OpInsertAfter(const OpInsertAfter& _o)
2585 : {
2586 0 : Init();
2587 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()), const_cast<PLayerParent*>((_o).afterParent()), const_cast<PLayerChild*>((_o).afterChild()));
2588 0 : }
2589 :
2590 : ~OpInsertAfter();
2591 :
2592 : void
2593 0 : operator=(const OpInsertAfter& _o)
2594 : {
2595 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()), const_cast<PLayerParent*>((_o).afterParent()), const_cast<PLayerChild*>((_o).afterChild()));
2596 0 : }
2597 :
2598 : bool
2599 : operator==(const OpInsertAfter& _o) const;
2600 :
2601 : PLayerParent*&
2602 0 : containerParent()
2603 : {
2604 0 : return containerParent_;
2605 : }
2606 : PLayerParent*
2607 0 : containerParent() const
2608 : {
2609 0 : return containerParent_;
2610 : }
2611 :
2612 : PLayerChild*&
2613 0 : containerChild()
2614 : {
2615 0 : return containerChild_;
2616 : }
2617 : PLayerChild*
2618 0 : containerChild() const
2619 : {
2620 0 : return containerChild_;
2621 : }
2622 :
2623 : PLayerParent*&
2624 0 : childLayerParent()
2625 : {
2626 0 : return childLayerParent_;
2627 : }
2628 : PLayerParent*
2629 0 : childLayerParent() const
2630 : {
2631 0 : return childLayerParent_;
2632 : }
2633 :
2634 : PLayerChild*&
2635 0 : childLayerChild()
2636 : {
2637 0 : return childLayerChild_;
2638 : }
2639 : PLayerChild*
2640 0 : childLayerChild() const
2641 : {
2642 0 : return childLayerChild_;
2643 : }
2644 :
2645 : PLayerParent*&
2646 0 : afterParent()
2647 : {
2648 0 : return afterParent_;
2649 : }
2650 : PLayerParent*
2651 0 : afterParent() const
2652 : {
2653 0 : return afterParent_;
2654 : }
2655 :
2656 : PLayerChild*&
2657 0 : afterChild()
2658 : {
2659 0 : return afterChild_;
2660 : }
2661 : PLayerChild*
2662 0 : afterChild() const
2663 : {
2664 0 : return afterChild_;
2665 : }
2666 :
2667 : private:
2668 : void
2669 : Init();
2670 :
2671 : void
2672 : Assign(
2673 : PLayerParent* _containerParent,
2674 : PLayerChild* _containerChild,
2675 : PLayerParent* _childLayerParent,
2676 : PLayerChild* _childLayerChild,
2677 : PLayerParent* _afterParent,
2678 : PLayerChild* _afterChild);
2679 :
2680 : PLayerParent* containerParent_;
2681 : PLayerChild* containerChild_;
2682 : PLayerParent* childLayerParent_;
2683 : PLayerChild* childLayerChild_;
2684 : PLayerParent* afterParent_;
2685 : PLayerChild* afterChild_;
2686 : };
2687 : } // namespace layers
2688 : } // namespace mozilla
2689 :
2690 : namespace mozilla {
2691 : namespace layers {
2692 : class PLayerParent;
2693 : } // namespace layers
2694 : } // namespace mozilla
2695 :
2696 : namespace mozilla {
2697 : namespace layers {
2698 : class PLayerChild;
2699 : } // namespace layers
2700 : } // namespace mozilla
2701 :
2702 :
2703 : //-----------------------------------------------------------------------------
2704 : // Declaration of the IPDL type |struct OpAppendChild|
2705 : //
2706 : namespace mozilla {
2707 : namespace layers {
2708 : class OpAppendChild MOZ_FINAL
2709 : {
2710 : private:
2711 : typedef mozilla::layers::PLayerParent PLayerParent;
2712 : typedef mozilla::layers::PLayerChild PLayerChild;
2713 :
2714 : public:
2715 : OpAppendChild();
2716 :
2717 0 : OpAppendChild(
2718 : PLayerParent* _containerParent,
2719 : PLayerChild* _containerChild,
2720 : PLayerParent* _childLayerParent,
2721 : PLayerChild* _childLayerChild)
2722 : {
2723 0 : Init();
2724 0 : Assign(_containerParent, _containerChild, _childLayerParent, _childLayerChild);
2725 0 : }
2726 :
2727 0 : OpAppendChild(const OpAppendChild& _o)
2728 : {
2729 0 : Init();
2730 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()));
2731 0 : }
2732 :
2733 : ~OpAppendChild();
2734 :
2735 : void
2736 0 : operator=(const OpAppendChild& _o)
2737 : {
2738 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()));
2739 0 : }
2740 :
2741 : bool
2742 : operator==(const OpAppendChild& _o) const;
2743 :
2744 : PLayerParent*&
2745 0 : containerParent()
2746 : {
2747 0 : return containerParent_;
2748 : }
2749 : PLayerParent*
2750 0 : containerParent() const
2751 : {
2752 0 : return containerParent_;
2753 : }
2754 :
2755 : PLayerChild*&
2756 0 : containerChild()
2757 : {
2758 0 : return containerChild_;
2759 : }
2760 : PLayerChild*
2761 0 : containerChild() const
2762 : {
2763 0 : return containerChild_;
2764 : }
2765 :
2766 : PLayerParent*&
2767 0 : childLayerParent()
2768 : {
2769 0 : return childLayerParent_;
2770 : }
2771 : PLayerParent*
2772 0 : childLayerParent() const
2773 : {
2774 0 : return childLayerParent_;
2775 : }
2776 :
2777 : PLayerChild*&
2778 0 : childLayerChild()
2779 : {
2780 0 : return childLayerChild_;
2781 : }
2782 : PLayerChild*
2783 0 : childLayerChild() const
2784 : {
2785 0 : return childLayerChild_;
2786 : }
2787 :
2788 : private:
2789 : void
2790 : Init();
2791 :
2792 : void
2793 : Assign(
2794 : PLayerParent* _containerParent,
2795 : PLayerChild* _containerChild,
2796 : PLayerParent* _childLayerParent,
2797 : PLayerChild* _childLayerChild);
2798 :
2799 : PLayerParent* containerParent_;
2800 : PLayerChild* containerChild_;
2801 : PLayerParent* childLayerParent_;
2802 : PLayerChild* childLayerChild_;
2803 : };
2804 : } // namespace layers
2805 : } // namespace mozilla
2806 :
2807 : namespace mozilla {
2808 : namespace layers {
2809 : class PLayerParent;
2810 : } // namespace layers
2811 : } // namespace mozilla
2812 :
2813 : namespace mozilla {
2814 : namespace layers {
2815 : class PLayerChild;
2816 : } // namespace layers
2817 : } // namespace mozilla
2818 :
2819 :
2820 : //-----------------------------------------------------------------------------
2821 : // Declaration of the IPDL type |struct OpRemoveChild|
2822 : //
2823 : namespace mozilla {
2824 : namespace layers {
2825 : class OpRemoveChild MOZ_FINAL
2826 : {
2827 : private:
2828 : typedef mozilla::layers::PLayerParent PLayerParent;
2829 : typedef mozilla::layers::PLayerChild PLayerChild;
2830 :
2831 : public:
2832 : OpRemoveChild();
2833 :
2834 0 : OpRemoveChild(
2835 : PLayerParent* _containerParent,
2836 : PLayerChild* _containerChild,
2837 : PLayerParent* _childLayerParent,
2838 : PLayerChild* _childLayerChild)
2839 : {
2840 0 : Init();
2841 0 : Assign(_containerParent, _containerChild, _childLayerParent, _childLayerChild);
2842 0 : }
2843 :
2844 0 : OpRemoveChild(const OpRemoveChild& _o)
2845 : {
2846 0 : Init();
2847 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()));
2848 0 : }
2849 :
2850 : ~OpRemoveChild();
2851 :
2852 : void
2853 0 : operator=(const OpRemoveChild& _o)
2854 : {
2855 0 : Assign(const_cast<PLayerParent*>((_o).containerParent()), const_cast<PLayerChild*>((_o).containerChild()), const_cast<PLayerParent*>((_o).childLayerParent()), const_cast<PLayerChild*>((_o).childLayerChild()));
2856 0 : }
2857 :
2858 : bool
2859 : operator==(const OpRemoveChild& _o) const;
2860 :
2861 : PLayerParent*&
2862 0 : containerParent()
2863 : {
2864 0 : return containerParent_;
2865 : }
2866 : PLayerParent*
2867 0 : containerParent() const
2868 : {
2869 0 : return containerParent_;
2870 : }
2871 :
2872 : PLayerChild*&
2873 0 : containerChild()
2874 : {
2875 0 : return containerChild_;
2876 : }
2877 : PLayerChild*
2878 0 : containerChild() const
2879 : {
2880 0 : return containerChild_;
2881 : }
2882 :
2883 : PLayerParent*&
2884 0 : childLayerParent()
2885 : {
2886 0 : return childLayerParent_;
2887 : }
2888 : PLayerParent*
2889 0 : childLayerParent() const
2890 : {
2891 0 : return childLayerParent_;
2892 : }
2893 :
2894 : PLayerChild*&
2895 0 : childLayerChild()
2896 : {
2897 0 : return childLayerChild_;
2898 : }
2899 : PLayerChild*
2900 0 : childLayerChild() const
2901 : {
2902 0 : return childLayerChild_;
2903 : }
2904 :
2905 : private:
2906 : void
2907 : Init();
2908 :
2909 : void
2910 : Assign(
2911 : PLayerParent* _containerParent,
2912 : PLayerChild* _containerChild,
2913 : PLayerParent* _childLayerParent,
2914 : PLayerChild* _childLayerChild);
2915 :
2916 : PLayerParent* containerParent_;
2917 : PLayerChild* containerChild_;
2918 : PLayerParent* childLayerParent_;
2919 : PLayerChild* childLayerChild_;
2920 : };
2921 : } // namespace layers
2922 : } // namespace mozilla
2923 :
2924 : namespace mozilla {
2925 : namespace layers {
2926 : class PLayerParent;
2927 : } // namespace layers
2928 : } // namespace mozilla
2929 :
2930 : namespace mozilla {
2931 : namespace layers {
2932 : class PLayerChild;
2933 : } // namespace layers
2934 : } // namespace mozilla
2935 :
2936 : namespace mozilla {
2937 : namespace layers {
2938 : class ThebesBuffer;
2939 : } // namespace layers
2940 : } // namespace mozilla
2941 :
2942 : //-----------------------------------------------------------------------------
2943 : // Declaration of the IPDL type |struct OpPaintThebesBuffer|
2944 : //
2945 : namespace mozilla {
2946 : namespace layers {
2947 : class OpPaintThebesBuffer MOZ_FINAL
2948 : {
2949 : private:
2950 : typedef mozilla::layers::PLayerParent PLayerParent;
2951 : typedef mozilla::layers::PLayerChild PLayerChild;
2952 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
2953 :
2954 : public:
2955 : OpPaintThebesBuffer();
2956 :
2957 0 : OpPaintThebesBuffer(
2958 : PLayerParent* _layerParent,
2959 : PLayerChild* _layerChild,
2960 : const ThebesBuffer& _newFrontBuffer,
2961 : const nsIntRegion& _updatedRegion)
2962 0 : {
2963 0 : Init();
2964 0 : Assign(_layerParent, _layerChild, _newFrontBuffer, _updatedRegion);
2965 0 : }
2966 :
2967 0 : OpPaintThebesBuffer(const OpPaintThebesBuffer& _o)
2968 0 : {
2969 0 : Init();
2970 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer(), (_o).updatedRegion());
2971 0 : }
2972 :
2973 : ~OpPaintThebesBuffer();
2974 :
2975 : void
2976 0 : operator=(const OpPaintThebesBuffer& _o)
2977 : {
2978 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer(), (_o).updatedRegion());
2979 0 : }
2980 :
2981 : bool
2982 : operator==(const OpPaintThebesBuffer& _o) const;
2983 :
2984 : PLayerParent*&
2985 0 : layerParent()
2986 : {
2987 0 : return layerParent_;
2988 : }
2989 : PLayerParent*
2990 0 : layerParent() const
2991 : {
2992 0 : return layerParent_;
2993 : }
2994 :
2995 : PLayerChild*&
2996 0 : layerChild()
2997 : {
2998 0 : return layerChild_;
2999 : }
3000 : PLayerChild*
3001 0 : layerChild() const
3002 : {
3003 0 : return layerChild_;
3004 : }
3005 :
3006 : ThebesBuffer&
3007 0 : newFrontBuffer()
3008 : {
3009 0 : return newFrontBuffer_;
3010 : }
3011 : const ThebesBuffer&
3012 0 : newFrontBuffer() const
3013 : {
3014 0 : return newFrontBuffer_;
3015 : }
3016 :
3017 : nsIntRegion&
3018 0 : updatedRegion()
3019 : {
3020 0 : return updatedRegion_;
3021 : }
3022 : const nsIntRegion&
3023 0 : updatedRegion() const
3024 : {
3025 0 : return updatedRegion_;
3026 : }
3027 :
3028 : private:
3029 : void
3030 : Init();
3031 :
3032 : void
3033 : Assign(
3034 : PLayerParent* _layerParent,
3035 : PLayerChild* _layerChild,
3036 : const ThebesBuffer& _newFrontBuffer,
3037 : const nsIntRegion& _updatedRegion);
3038 :
3039 : PLayerParent* layerParent_;
3040 : PLayerChild* layerChild_;
3041 : ThebesBuffer newFrontBuffer_;
3042 : nsIntRegion updatedRegion_;
3043 : };
3044 : } // namespace layers
3045 : } // namespace mozilla
3046 :
3047 : namespace mozilla {
3048 : namespace layers {
3049 : class PLayerParent;
3050 : } // namespace layers
3051 : } // namespace mozilla
3052 :
3053 : namespace mozilla {
3054 : namespace layers {
3055 : class PLayerChild;
3056 : } // namespace layers
3057 : } // namespace mozilla
3058 :
3059 : namespace mozilla {
3060 : namespace layers {
3061 : class CanvasSurface;
3062 : } // namespace layers
3063 : } // namespace mozilla
3064 :
3065 : //-----------------------------------------------------------------------------
3066 : // Declaration of the IPDL type |struct OpPaintCanvas|
3067 : //
3068 : namespace mozilla {
3069 : namespace layers {
3070 : class OpPaintCanvas MOZ_FINAL
3071 : {
3072 : private:
3073 : typedef mozilla::layers::PLayerParent PLayerParent;
3074 : typedef mozilla::layers::PLayerChild PLayerChild;
3075 : typedef mozilla::layers::CanvasSurface CanvasSurface;
3076 :
3077 : public:
3078 : OpPaintCanvas();
3079 :
3080 0 : OpPaintCanvas(
3081 : PLayerParent* _layerParent,
3082 : PLayerChild* _layerChild,
3083 : const CanvasSurface& _newFrontBuffer,
3084 : const bool& _needYFlip)
3085 0 : {
3086 0 : Init();
3087 0 : Assign(_layerParent, _layerChild, _newFrontBuffer, _needYFlip);
3088 0 : }
3089 :
3090 0 : OpPaintCanvas(const OpPaintCanvas& _o)
3091 0 : {
3092 0 : Init();
3093 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer(), (_o).needYFlip());
3094 0 : }
3095 :
3096 : ~OpPaintCanvas();
3097 :
3098 : void
3099 0 : operator=(const OpPaintCanvas& _o)
3100 : {
3101 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer(), (_o).needYFlip());
3102 0 : }
3103 :
3104 : bool
3105 : operator==(const OpPaintCanvas& _o) const;
3106 :
3107 : PLayerParent*&
3108 0 : layerParent()
3109 : {
3110 0 : return layerParent_;
3111 : }
3112 : PLayerParent*
3113 0 : layerParent() const
3114 : {
3115 0 : return layerParent_;
3116 : }
3117 :
3118 : PLayerChild*&
3119 0 : layerChild()
3120 : {
3121 0 : return layerChild_;
3122 : }
3123 : PLayerChild*
3124 0 : layerChild() const
3125 : {
3126 0 : return layerChild_;
3127 : }
3128 :
3129 : CanvasSurface&
3130 0 : newFrontBuffer()
3131 : {
3132 0 : return newFrontBuffer_;
3133 : }
3134 : const CanvasSurface&
3135 0 : newFrontBuffer() const
3136 : {
3137 0 : return newFrontBuffer_;
3138 : }
3139 :
3140 : bool&
3141 0 : needYFlip()
3142 : {
3143 0 : return needYFlip_;
3144 : }
3145 : const bool&
3146 0 : needYFlip() const
3147 : {
3148 0 : return needYFlip_;
3149 : }
3150 :
3151 : private:
3152 : void
3153 : Init();
3154 :
3155 : void
3156 : Assign(
3157 : PLayerParent* _layerParent,
3158 : PLayerChild* _layerChild,
3159 : const CanvasSurface& _newFrontBuffer,
3160 : const bool& _needYFlip);
3161 :
3162 : PLayerParent* layerParent_;
3163 : PLayerChild* layerChild_;
3164 : CanvasSurface newFrontBuffer_;
3165 : bool needYFlip_;
3166 : };
3167 : } // namespace layers
3168 : } // namespace mozilla
3169 :
3170 : namespace mozilla {
3171 : namespace layers {
3172 : class PLayerParent;
3173 : } // namespace layers
3174 : } // namespace mozilla
3175 :
3176 : namespace mozilla {
3177 : namespace layers {
3178 : class PLayerChild;
3179 : } // namespace layers
3180 : } // namespace mozilla
3181 :
3182 : namespace mozilla {
3183 : namespace layers {
3184 : class SharedImage;
3185 : } // namespace layers
3186 : } // namespace mozilla
3187 :
3188 : //-----------------------------------------------------------------------------
3189 : // Declaration of the IPDL type |struct OpPaintImage|
3190 : //
3191 : namespace mozilla {
3192 : namespace layers {
3193 : class OpPaintImage MOZ_FINAL
3194 : {
3195 : private:
3196 : typedef mozilla::layers::PLayerParent PLayerParent;
3197 : typedef mozilla::layers::PLayerChild PLayerChild;
3198 : typedef mozilla::layers::SharedImage SharedImage;
3199 :
3200 : public:
3201 : OpPaintImage();
3202 :
3203 0 : OpPaintImage(
3204 : PLayerParent* _layerParent,
3205 : PLayerChild* _layerChild,
3206 : const SharedImage& _newFrontBuffer)
3207 0 : {
3208 0 : Init();
3209 0 : Assign(_layerParent, _layerChild, _newFrontBuffer);
3210 0 : }
3211 :
3212 0 : OpPaintImage(const OpPaintImage& _o)
3213 0 : {
3214 0 : Init();
3215 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer());
3216 0 : }
3217 :
3218 : ~OpPaintImage();
3219 :
3220 : void
3221 0 : operator=(const OpPaintImage& _o)
3222 : {
3223 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newFrontBuffer());
3224 0 : }
3225 :
3226 : bool
3227 : operator==(const OpPaintImage& _o) const;
3228 :
3229 : PLayerParent*&
3230 0 : layerParent()
3231 : {
3232 0 : return layerParent_;
3233 : }
3234 : PLayerParent*
3235 0 : layerParent() const
3236 : {
3237 0 : return layerParent_;
3238 : }
3239 :
3240 : PLayerChild*&
3241 0 : layerChild()
3242 : {
3243 0 : return layerChild_;
3244 : }
3245 : PLayerChild*
3246 0 : layerChild() const
3247 : {
3248 0 : return layerChild_;
3249 : }
3250 :
3251 : SharedImage&
3252 0 : newFrontBuffer()
3253 : {
3254 0 : return newFrontBuffer_;
3255 : }
3256 : const SharedImage&
3257 0 : newFrontBuffer() const
3258 : {
3259 0 : return newFrontBuffer_;
3260 : }
3261 :
3262 : private:
3263 : void
3264 : Init();
3265 :
3266 : void
3267 : Assign(
3268 : PLayerParent* _layerParent,
3269 : PLayerChild* _layerChild,
3270 : const SharedImage& _newFrontBuffer);
3271 :
3272 : PLayerParent* layerParent_;
3273 : PLayerChild* layerChild_;
3274 : SharedImage newFrontBuffer_;
3275 : };
3276 : } // namespace layers
3277 : } // namespace mozilla
3278 :
3279 : namespace mozilla {
3280 : namespace layers {
3281 : class OpCreateThebesLayer;
3282 : } // namespace layers
3283 : } // namespace mozilla
3284 : namespace mozilla {
3285 : namespace layers {
3286 : class OpCreateContainerLayer;
3287 : } // namespace layers
3288 : } // namespace mozilla
3289 : namespace mozilla {
3290 : namespace layers {
3291 : class OpCreateImageLayer;
3292 : } // namespace layers
3293 : } // namespace mozilla
3294 : namespace mozilla {
3295 : namespace layers {
3296 : class OpCreateColorLayer;
3297 : } // namespace layers
3298 : } // namespace mozilla
3299 : namespace mozilla {
3300 : namespace layers {
3301 : class OpCreateCanvasLayer;
3302 : } // namespace layers
3303 : } // namespace mozilla
3304 : namespace mozilla {
3305 : namespace layers {
3306 : class OpSetLayerAttributes;
3307 : } // namespace layers
3308 : } // namespace mozilla
3309 : namespace mozilla {
3310 : namespace layers {
3311 : class OpSetRoot;
3312 : } // namespace layers
3313 : } // namespace mozilla
3314 : namespace mozilla {
3315 : namespace layers {
3316 : class OpInsertAfter;
3317 : } // namespace layers
3318 : } // namespace mozilla
3319 : namespace mozilla {
3320 : namespace layers {
3321 : class OpAppendChild;
3322 : } // namespace layers
3323 : } // namespace mozilla
3324 : namespace mozilla {
3325 : namespace layers {
3326 : class OpRemoveChild;
3327 : } // namespace layers
3328 : } // namespace mozilla
3329 : namespace mozilla {
3330 : namespace layers {
3331 : class OpPaintThebesBuffer;
3332 : } // namespace layers
3333 : } // namespace mozilla
3334 : namespace mozilla {
3335 : namespace layers {
3336 : class OpPaintCanvas;
3337 : } // namespace layers
3338 : } // namespace mozilla
3339 : namespace mozilla {
3340 : namespace layers {
3341 : class OpPaintImage;
3342 : } // namespace layers
3343 : } // namespace mozilla
3344 :
3345 : //-----------------------------------------------------------------------------
3346 : // Declaration of the IPDL type |union Edit|
3347 : //
3348 : namespace mozilla {
3349 : namespace layers {
3350 : class Edit MOZ_FINAL
3351 : {
3352 : public:
3353 : enum Type {
3354 : T__None,
3355 : TOpCreateThebesLayer = 1,
3356 : TOpCreateContainerLayer,
3357 : TOpCreateImageLayer,
3358 : TOpCreateColorLayer,
3359 : TOpCreateCanvasLayer,
3360 : TOpSetLayerAttributes,
3361 : TOpSetRoot,
3362 : TOpInsertAfter,
3363 : TOpAppendChild,
3364 : TOpRemoveChild,
3365 : TOpPaintThebesBuffer,
3366 : TOpPaintCanvas,
3367 : TOpPaintImage,
3368 : T__Last = TOpPaintImage
3369 : };
3370 :
3371 : private:
3372 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
3373 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
3374 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
3375 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
3376 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
3377 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
3378 : typedef mozilla::layers::OpSetRoot OpSetRoot;
3379 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
3380 : typedef mozilla::layers::OpAppendChild OpAppendChild;
3381 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
3382 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
3383 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
3384 : typedef mozilla::layers::OpPaintImage OpPaintImage;
3385 : typedef OpCreateThebesLayer OpCreateThebesLayer__tdef;
3386 : typedef OpCreateContainerLayer OpCreateContainerLayer__tdef;
3387 : typedef OpCreateImageLayer OpCreateImageLayer__tdef;
3388 : typedef OpCreateColorLayer OpCreateColorLayer__tdef;
3389 : typedef OpCreateCanvasLayer OpCreateCanvasLayer__tdef;
3390 : typedef OpSetLayerAttributes OpSetLayerAttributes__tdef;
3391 : typedef OpSetRoot OpSetRoot__tdef;
3392 : typedef OpInsertAfter OpInsertAfter__tdef;
3393 : typedef OpAppendChild OpAppendChild__tdef;
3394 : typedef OpRemoveChild OpRemoveChild__tdef;
3395 : typedef OpPaintThebesBuffer OpPaintThebesBuffer__tdef;
3396 : typedef OpPaintCanvas OpPaintCanvas__tdef;
3397 : typedef OpPaintImage OpPaintImage__tdef;
3398 :
3399 : union Value {
3400 : char VOpCreateThebesLayer[sizeof(OpCreateThebesLayer)];
3401 : char VOpCreateContainerLayer[sizeof(OpCreateContainerLayer)];
3402 : char VOpCreateImageLayer[sizeof(OpCreateImageLayer)];
3403 : char VOpCreateColorLayer[sizeof(OpCreateColorLayer)];
3404 : char VOpCreateCanvasLayer[sizeof(OpCreateCanvasLayer)];
3405 : char VOpSetLayerAttributes[sizeof(OpSetLayerAttributes)];
3406 : char VOpSetRoot[sizeof(OpSetRoot)];
3407 : char VOpInsertAfter[sizeof(OpInsertAfter)];
3408 : char VOpAppendChild[sizeof(OpAppendChild)];
3409 : char VOpRemoveChild[sizeof(OpRemoveChild)];
3410 : char VOpPaintThebesBuffer[sizeof(OpPaintThebesBuffer)];
3411 : char VOpPaintCanvas[sizeof(OpPaintCanvas)];
3412 : char VOpPaintImage[sizeof(OpPaintImage)];
3413 : };
3414 :
3415 : OpCreateThebesLayer*
3416 0 : ptr_OpCreateThebesLayer()
3417 : {
3418 0 : return reinterpret_cast<OpCreateThebesLayer*>((&((mValue).VOpCreateThebesLayer)));
3419 : }
3420 : const OpCreateThebesLayer* const
3421 0 : constptr_OpCreateThebesLayer() const
3422 : {
3423 0 : return reinterpret_cast<const OpCreateThebesLayer* const>((&((mValue).VOpCreateThebesLayer)));
3424 : }
3425 : OpCreateContainerLayer*
3426 0 : ptr_OpCreateContainerLayer()
3427 : {
3428 0 : return reinterpret_cast<OpCreateContainerLayer*>((&((mValue).VOpCreateContainerLayer)));
3429 : }
3430 : const OpCreateContainerLayer* const
3431 0 : constptr_OpCreateContainerLayer() const
3432 : {
3433 0 : return reinterpret_cast<const OpCreateContainerLayer* const>((&((mValue).VOpCreateContainerLayer)));
3434 : }
3435 : OpCreateImageLayer*
3436 0 : ptr_OpCreateImageLayer()
3437 : {
3438 0 : return reinterpret_cast<OpCreateImageLayer*>((&((mValue).VOpCreateImageLayer)));
3439 : }
3440 : const OpCreateImageLayer* const
3441 0 : constptr_OpCreateImageLayer() const
3442 : {
3443 0 : return reinterpret_cast<const OpCreateImageLayer* const>((&((mValue).VOpCreateImageLayer)));
3444 : }
3445 : OpCreateColorLayer*
3446 0 : ptr_OpCreateColorLayer()
3447 : {
3448 0 : return reinterpret_cast<OpCreateColorLayer*>((&((mValue).VOpCreateColorLayer)));
3449 : }
3450 : const OpCreateColorLayer* const
3451 0 : constptr_OpCreateColorLayer() const
3452 : {
3453 0 : return reinterpret_cast<const OpCreateColorLayer* const>((&((mValue).VOpCreateColorLayer)));
3454 : }
3455 : OpCreateCanvasLayer*
3456 0 : ptr_OpCreateCanvasLayer()
3457 : {
3458 0 : return reinterpret_cast<OpCreateCanvasLayer*>((&((mValue).VOpCreateCanvasLayer)));
3459 : }
3460 : const OpCreateCanvasLayer* const
3461 0 : constptr_OpCreateCanvasLayer() const
3462 : {
3463 0 : return reinterpret_cast<const OpCreateCanvasLayer* const>((&((mValue).VOpCreateCanvasLayer)));
3464 : }
3465 : OpSetLayerAttributes*
3466 0 : ptr_OpSetLayerAttributes()
3467 : {
3468 0 : return reinterpret_cast<OpSetLayerAttributes*>((&((mValue).VOpSetLayerAttributes)));
3469 : }
3470 : const OpSetLayerAttributes* const
3471 0 : constptr_OpSetLayerAttributes() const
3472 : {
3473 0 : return reinterpret_cast<const OpSetLayerAttributes* const>((&((mValue).VOpSetLayerAttributes)));
3474 : }
3475 : OpSetRoot*
3476 0 : ptr_OpSetRoot()
3477 : {
3478 0 : return reinterpret_cast<OpSetRoot*>((&((mValue).VOpSetRoot)));
3479 : }
3480 : const OpSetRoot* const
3481 0 : constptr_OpSetRoot() const
3482 : {
3483 0 : return reinterpret_cast<const OpSetRoot* const>((&((mValue).VOpSetRoot)));
3484 : }
3485 : OpInsertAfter*
3486 0 : ptr_OpInsertAfter()
3487 : {
3488 0 : return reinterpret_cast<OpInsertAfter*>((&((mValue).VOpInsertAfter)));
3489 : }
3490 : const OpInsertAfter* const
3491 0 : constptr_OpInsertAfter() const
3492 : {
3493 0 : return reinterpret_cast<const OpInsertAfter* const>((&((mValue).VOpInsertAfter)));
3494 : }
3495 : OpAppendChild*
3496 0 : ptr_OpAppendChild()
3497 : {
3498 0 : return reinterpret_cast<OpAppendChild*>((&((mValue).VOpAppendChild)));
3499 : }
3500 : const OpAppendChild* const
3501 0 : constptr_OpAppendChild() const
3502 : {
3503 0 : return reinterpret_cast<const OpAppendChild* const>((&((mValue).VOpAppendChild)));
3504 : }
3505 : OpRemoveChild*
3506 0 : ptr_OpRemoveChild()
3507 : {
3508 0 : return reinterpret_cast<OpRemoveChild*>((&((mValue).VOpRemoveChild)));
3509 : }
3510 : const OpRemoveChild* const
3511 0 : constptr_OpRemoveChild() const
3512 : {
3513 0 : return reinterpret_cast<const OpRemoveChild* const>((&((mValue).VOpRemoveChild)));
3514 : }
3515 : OpPaintThebesBuffer*
3516 0 : ptr_OpPaintThebesBuffer()
3517 : {
3518 0 : return reinterpret_cast<OpPaintThebesBuffer*>((&((mValue).VOpPaintThebesBuffer)));
3519 : }
3520 : const OpPaintThebesBuffer* const
3521 0 : constptr_OpPaintThebesBuffer() const
3522 : {
3523 0 : return reinterpret_cast<const OpPaintThebesBuffer* const>((&((mValue).VOpPaintThebesBuffer)));
3524 : }
3525 : OpPaintCanvas*
3526 0 : ptr_OpPaintCanvas()
3527 : {
3528 0 : return reinterpret_cast<OpPaintCanvas*>((&((mValue).VOpPaintCanvas)));
3529 : }
3530 : const OpPaintCanvas* const
3531 0 : constptr_OpPaintCanvas() const
3532 : {
3533 0 : return reinterpret_cast<const OpPaintCanvas* const>((&((mValue).VOpPaintCanvas)));
3534 : }
3535 : OpPaintImage*
3536 0 : ptr_OpPaintImage()
3537 : {
3538 0 : return reinterpret_cast<OpPaintImage*>((&((mValue).VOpPaintImage)));
3539 : }
3540 : const OpPaintImage* const
3541 0 : constptr_OpPaintImage() const
3542 : {
3543 0 : return reinterpret_cast<const OpPaintImage* const>((&((mValue).VOpPaintImage)));
3544 : }
3545 :
3546 : bool
3547 : MaybeDestroy(Type aNewType);
3548 :
3549 : void
3550 0 : AssertSanity() const
3551 : {
3552 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
3553 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
3554 0 : }
3555 : void
3556 0 : AssertSanity(Type aType) const
3557 : {
3558 0 : AssertSanity();
3559 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
3560 0 : }
3561 :
3562 : public:
3563 0 : Edit() :
3564 0 : mType(T__None)
3565 : {
3566 0 : }
3567 :
3568 : Edit(const OpCreateThebesLayer& aOther);
3569 :
3570 : Edit(const OpCreateContainerLayer& aOther);
3571 :
3572 : Edit(const OpCreateImageLayer& aOther);
3573 :
3574 : Edit(const OpCreateColorLayer& aOther);
3575 :
3576 : Edit(const OpCreateCanvasLayer& aOther);
3577 :
3578 : Edit(const OpSetLayerAttributes& aOther);
3579 :
3580 : Edit(const OpSetRoot& aOther);
3581 :
3582 : Edit(const OpInsertAfter& aOther);
3583 :
3584 : Edit(const OpAppendChild& aOther);
3585 :
3586 : Edit(const OpRemoveChild& aOther);
3587 :
3588 : Edit(const OpPaintThebesBuffer& aOther);
3589 :
3590 : Edit(const OpPaintCanvas& aOther);
3591 :
3592 : Edit(const OpPaintImage& aOther);
3593 :
3594 : Edit(const Edit& aOther);
3595 :
3596 : ~Edit();
3597 :
3598 : Type
3599 0 : type() const
3600 : {
3601 0 : return mType;
3602 : }
3603 :
3604 : Edit&
3605 : operator=(const OpCreateThebesLayer& aRhs);
3606 :
3607 : Edit&
3608 : operator=(const OpCreateContainerLayer& aRhs);
3609 :
3610 : Edit&
3611 : operator=(const OpCreateImageLayer& aRhs);
3612 :
3613 : Edit&
3614 : operator=(const OpCreateColorLayer& aRhs);
3615 :
3616 : Edit&
3617 : operator=(const OpCreateCanvasLayer& aRhs);
3618 :
3619 : Edit&
3620 : operator=(const OpSetLayerAttributes& aRhs);
3621 :
3622 : Edit&
3623 : operator=(const OpSetRoot& aRhs);
3624 :
3625 : Edit&
3626 : operator=(const OpInsertAfter& aRhs);
3627 :
3628 : Edit&
3629 : operator=(const OpAppendChild& aRhs);
3630 :
3631 : Edit&
3632 : operator=(const OpRemoveChild& aRhs);
3633 :
3634 : Edit&
3635 : operator=(const OpPaintThebesBuffer& aRhs);
3636 :
3637 : Edit&
3638 : operator=(const OpPaintCanvas& aRhs);
3639 :
3640 : Edit&
3641 : operator=(const OpPaintImage& aRhs);
3642 :
3643 : Edit&
3644 : operator=(const Edit& aRhs);
3645 :
3646 : bool
3647 : operator==(const OpCreateThebesLayer& aRhs) const;
3648 :
3649 : bool
3650 : operator==(const OpCreateContainerLayer& aRhs) const;
3651 :
3652 : bool
3653 : operator==(const OpCreateImageLayer& aRhs) const;
3654 :
3655 : bool
3656 : operator==(const OpCreateColorLayer& aRhs) const;
3657 :
3658 : bool
3659 : operator==(const OpCreateCanvasLayer& aRhs) const;
3660 :
3661 : bool
3662 : operator==(const OpSetLayerAttributes& aRhs) const;
3663 :
3664 : bool
3665 : operator==(const OpSetRoot& aRhs) const;
3666 :
3667 : bool
3668 : operator==(const OpInsertAfter& aRhs) const;
3669 :
3670 : bool
3671 : operator==(const OpAppendChild& aRhs) const;
3672 :
3673 : bool
3674 : operator==(const OpRemoveChild& aRhs) const;
3675 :
3676 : bool
3677 : operator==(const OpPaintThebesBuffer& aRhs) const;
3678 :
3679 : bool
3680 : operator==(const OpPaintCanvas& aRhs) const;
3681 :
3682 : bool
3683 : operator==(const OpPaintImage& aRhs) const;
3684 :
3685 : bool
3686 : operator==(const Edit& aRhs) const;
3687 :
3688 : OpCreateThebesLayer&
3689 0 : get_OpCreateThebesLayer()
3690 : {
3691 0 : AssertSanity(TOpCreateThebesLayer);
3692 0 : return (*(ptr_OpCreateThebesLayer()));
3693 : }
3694 : const OpCreateThebesLayer&
3695 0 : get_OpCreateThebesLayer() const
3696 : {
3697 0 : AssertSanity(TOpCreateThebesLayer);
3698 0 : return (*(constptr_OpCreateThebesLayer()));
3699 : }
3700 : operator OpCreateThebesLayer&()
3701 : {
3702 : return get_OpCreateThebesLayer();
3703 : }
3704 : operator const OpCreateThebesLayer&() const
3705 : {
3706 : return get_OpCreateThebesLayer();
3707 : }
3708 :
3709 : OpCreateContainerLayer&
3710 0 : get_OpCreateContainerLayer()
3711 : {
3712 0 : AssertSanity(TOpCreateContainerLayer);
3713 0 : return (*(ptr_OpCreateContainerLayer()));
3714 : }
3715 : const OpCreateContainerLayer&
3716 0 : get_OpCreateContainerLayer() const
3717 : {
3718 0 : AssertSanity(TOpCreateContainerLayer);
3719 0 : return (*(constptr_OpCreateContainerLayer()));
3720 : }
3721 : operator OpCreateContainerLayer&()
3722 : {
3723 : return get_OpCreateContainerLayer();
3724 : }
3725 : operator const OpCreateContainerLayer&() const
3726 : {
3727 : return get_OpCreateContainerLayer();
3728 : }
3729 :
3730 : OpCreateImageLayer&
3731 0 : get_OpCreateImageLayer()
3732 : {
3733 0 : AssertSanity(TOpCreateImageLayer);
3734 0 : return (*(ptr_OpCreateImageLayer()));
3735 : }
3736 : const OpCreateImageLayer&
3737 0 : get_OpCreateImageLayer() const
3738 : {
3739 0 : AssertSanity(TOpCreateImageLayer);
3740 0 : return (*(constptr_OpCreateImageLayer()));
3741 : }
3742 : operator OpCreateImageLayer&()
3743 : {
3744 : return get_OpCreateImageLayer();
3745 : }
3746 : operator const OpCreateImageLayer&() const
3747 : {
3748 : return get_OpCreateImageLayer();
3749 : }
3750 :
3751 : OpCreateColorLayer&
3752 0 : get_OpCreateColorLayer()
3753 : {
3754 0 : AssertSanity(TOpCreateColorLayer);
3755 0 : return (*(ptr_OpCreateColorLayer()));
3756 : }
3757 : const OpCreateColorLayer&
3758 0 : get_OpCreateColorLayer() const
3759 : {
3760 0 : AssertSanity(TOpCreateColorLayer);
3761 0 : return (*(constptr_OpCreateColorLayer()));
3762 : }
3763 : operator OpCreateColorLayer&()
3764 : {
3765 : return get_OpCreateColorLayer();
3766 : }
3767 : operator const OpCreateColorLayer&() const
3768 : {
3769 : return get_OpCreateColorLayer();
3770 : }
3771 :
3772 : OpCreateCanvasLayer&
3773 0 : get_OpCreateCanvasLayer()
3774 : {
3775 0 : AssertSanity(TOpCreateCanvasLayer);
3776 0 : return (*(ptr_OpCreateCanvasLayer()));
3777 : }
3778 : const OpCreateCanvasLayer&
3779 0 : get_OpCreateCanvasLayer() const
3780 : {
3781 0 : AssertSanity(TOpCreateCanvasLayer);
3782 0 : return (*(constptr_OpCreateCanvasLayer()));
3783 : }
3784 : operator OpCreateCanvasLayer&()
3785 : {
3786 : return get_OpCreateCanvasLayer();
3787 : }
3788 : operator const OpCreateCanvasLayer&() const
3789 : {
3790 : return get_OpCreateCanvasLayer();
3791 : }
3792 :
3793 : OpSetLayerAttributes&
3794 0 : get_OpSetLayerAttributes()
3795 : {
3796 0 : AssertSanity(TOpSetLayerAttributes);
3797 0 : return (*(ptr_OpSetLayerAttributes()));
3798 : }
3799 : const OpSetLayerAttributes&
3800 0 : get_OpSetLayerAttributes() const
3801 : {
3802 0 : AssertSanity(TOpSetLayerAttributes);
3803 0 : return (*(constptr_OpSetLayerAttributes()));
3804 : }
3805 : operator OpSetLayerAttributes&()
3806 : {
3807 : return get_OpSetLayerAttributes();
3808 : }
3809 : operator const OpSetLayerAttributes&() const
3810 : {
3811 : return get_OpSetLayerAttributes();
3812 : }
3813 :
3814 : OpSetRoot&
3815 0 : get_OpSetRoot()
3816 : {
3817 0 : AssertSanity(TOpSetRoot);
3818 0 : return (*(ptr_OpSetRoot()));
3819 : }
3820 : const OpSetRoot&
3821 0 : get_OpSetRoot() const
3822 : {
3823 0 : AssertSanity(TOpSetRoot);
3824 0 : return (*(constptr_OpSetRoot()));
3825 : }
3826 : operator OpSetRoot&()
3827 : {
3828 : return get_OpSetRoot();
3829 : }
3830 : operator const OpSetRoot&() const
3831 : {
3832 : return get_OpSetRoot();
3833 : }
3834 :
3835 : OpInsertAfter&
3836 0 : get_OpInsertAfter()
3837 : {
3838 0 : AssertSanity(TOpInsertAfter);
3839 0 : return (*(ptr_OpInsertAfter()));
3840 : }
3841 : const OpInsertAfter&
3842 0 : get_OpInsertAfter() const
3843 : {
3844 0 : AssertSanity(TOpInsertAfter);
3845 0 : return (*(constptr_OpInsertAfter()));
3846 : }
3847 : operator OpInsertAfter&()
3848 : {
3849 : return get_OpInsertAfter();
3850 : }
3851 : operator const OpInsertAfter&() const
3852 : {
3853 : return get_OpInsertAfter();
3854 : }
3855 :
3856 : OpAppendChild&
3857 0 : get_OpAppendChild()
3858 : {
3859 0 : AssertSanity(TOpAppendChild);
3860 0 : return (*(ptr_OpAppendChild()));
3861 : }
3862 : const OpAppendChild&
3863 0 : get_OpAppendChild() const
3864 : {
3865 0 : AssertSanity(TOpAppendChild);
3866 0 : return (*(constptr_OpAppendChild()));
3867 : }
3868 : operator OpAppendChild&()
3869 : {
3870 : return get_OpAppendChild();
3871 : }
3872 : operator const OpAppendChild&() const
3873 : {
3874 : return get_OpAppendChild();
3875 : }
3876 :
3877 : OpRemoveChild&
3878 0 : get_OpRemoveChild()
3879 : {
3880 0 : AssertSanity(TOpRemoveChild);
3881 0 : return (*(ptr_OpRemoveChild()));
3882 : }
3883 : const OpRemoveChild&
3884 0 : get_OpRemoveChild() const
3885 : {
3886 0 : AssertSanity(TOpRemoveChild);
3887 0 : return (*(constptr_OpRemoveChild()));
3888 : }
3889 : operator OpRemoveChild&()
3890 : {
3891 : return get_OpRemoveChild();
3892 : }
3893 : operator const OpRemoveChild&() const
3894 : {
3895 : return get_OpRemoveChild();
3896 : }
3897 :
3898 : OpPaintThebesBuffer&
3899 0 : get_OpPaintThebesBuffer()
3900 : {
3901 0 : AssertSanity(TOpPaintThebesBuffer);
3902 0 : return (*(ptr_OpPaintThebesBuffer()));
3903 : }
3904 : const OpPaintThebesBuffer&
3905 0 : get_OpPaintThebesBuffer() const
3906 : {
3907 0 : AssertSanity(TOpPaintThebesBuffer);
3908 0 : return (*(constptr_OpPaintThebesBuffer()));
3909 : }
3910 : operator OpPaintThebesBuffer&()
3911 : {
3912 : return get_OpPaintThebesBuffer();
3913 : }
3914 : operator const OpPaintThebesBuffer&() const
3915 : {
3916 : return get_OpPaintThebesBuffer();
3917 : }
3918 :
3919 : OpPaintCanvas&
3920 0 : get_OpPaintCanvas()
3921 : {
3922 0 : AssertSanity(TOpPaintCanvas);
3923 0 : return (*(ptr_OpPaintCanvas()));
3924 : }
3925 : const OpPaintCanvas&
3926 0 : get_OpPaintCanvas() const
3927 : {
3928 0 : AssertSanity(TOpPaintCanvas);
3929 0 : return (*(constptr_OpPaintCanvas()));
3930 : }
3931 : operator OpPaintCanvas&()
3932 : {
3933 : return get_OpPaintCanvas();
3934 : }
3935 : operator const OpPaintCanvas&() const
3936 : {
3937 : return get_OpPaintCanvas();
3938 : }
3939 :
3940 : OpPaintImage&
3941 0 : get_OpPaintImage()
3942 : {
3943 0 : AssertSanity(TOpPaintImage);
3944 0 : return (*(ptr_OpPaintImage()));
3945 : }
3946 : const OpPaintImage&
3947 0 : get_OpPaintImage() const
3948 : {
3949 0 : AssertSanity(TOpPaintImage);
3950 0 : return (*(constptr_OpPaintImage()));
3951 : }
3952 : operator OpPaintImage&()
3953 : {
3954 : return get_OpPaintImage();
3955 : }
3956 : operator const OpPaintImage&() const
3957 : {
3958 : return get_OpPaintImage();
3959 : }
3960 :
3961 : private:
3962 : Value mValue;
3963 : Type mType;
3964 : };
3965 : } // namespace layers
3966 : } // namespace mozilla
3967 :
3968 : namespace mozilla {
3969 : namespace layers {
3970 : class PLayerParent;
3971 : } // namespace layers
3972 : } // namespace mozilla
3973 :
3974 : namespace mozilla {
3975 : namespace layers {
3976 : class PLayerChild;
3977 : } // namespace layers
3978 : } // namespace mozilla
3979 :
3980 : namespace mozilla {
3981 : namespace layers {
3982 : class CanvasSurface;
3983 : } // namespace layers
3984 : } // namespace mozilla
3985 :
3986 : //-----------------------------------------------------------------------------
3987 : // Declaration of the IPDL type |struct OpBufferSwap|
3988 : //
3989 : namespace mozilla {
3990 : namespace layers {
3991 : class OpBufferSwap MOZ_FINAL
3992 : {
3993 : private:
3994 : typedef mozilla::layers::PLayerParent PLayerParent;
3995 : typedef mozilla::layers::PLayerChild PLayerChild;
3996 : typedef mozilla::layers::CanvasSurface CanvasSurface;
3997 :
3998 : public:
3999 : OpBufferSwap();
4000 :
4001 0 : OpBufferSwap(
4002 : PLayerParent* _layerParent,
4003 : PLayerChild* _layerChild,
4004 : const CanvasSurface& _newBackBuffer)
4005 0 : {
4006 0 : Init();
4007 0 : Assign(_layerParent, _layerChild, _newBackBuffer);
4008 0 : }
4009 :
4010 0 : OpBufferSwap(const OpBufferSwap& _o)
4011 0 : {
4012 0 : Init();
4013 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackBuffer());
4014 0 : }
4015 :
4016 : ~OpBufferSwap();
4017 :
4018 : void
4019 0 : operator=(const OpBufferSwap& _o)
4020 : {
4021 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackBuffer());
4022 0 : }
4023 :
4024 : bool
4025 : operator==(const OpBufferSwap& _o) const;
4026 :
4027 : PLayerParent*&
4028 0 : layerParent()
4029 : {
4030 0 : return layerParent_;
4031 : }
4032 : PLayerParent*
4033 0 : layerParent() const
4034 : {
4035 0 : return layerParent_;
4036 : }
4037 :
4038 : PLayerChild*&
4039 0 : layerChild()
4040 : {
4041 0 : return layerChild_;
4042 : }
4043 : PLayerChild*
4044 0 : layerChild() const
4045 : {
4046 0 : return layerChild_;
4047 : }
4048 :
4049 : CanvasSurface&
4050 0 : newBackBuffer()
4051 : {
4052 0 : return newBackBuffer_;
4053 : }
4054 : const CanvasSurface&
4055 0 : newBackBuffer() const
4056 : {
4057 0 : return newBackBuffer_;
4058 : }
4059 :
4060 : private:
4061 : void
4062 : Init();
4063 :
4064 : void
4065 : Assign(
4066 : PLayerParent* _layerParent,
4067 : PLayerChild* _layerChild,
4068 : const CanvasSurface& _newBackBuffer);
4069 :
4070 : PLayerParent* layerParent_;
4071 : PLayerChild* layerChild_;
4072 : CanvasSurface newBackBuffer_;
4073 : };
4074 : } // namespace layers
4075 : } // namespace mozilla
4076 :
4077 : namespace mozilla {
4078 : namespace layers {
4079 : class PLayerParent;
4080 : } // namespace layers
4081 : } // namespace mozilla
4082 :
4083 : namespace mozilla {
4084 : namespace layers {
4085 : class PLayerChild;
4086 : } // namespace layers
4087 : } // namespace mozilla
4088 :
4089 : namespace mozilla {
4090 : namespace layers {
4091 : class SharedImage;
4092 : } // namespace layers
4093 : } // namespace mozilla
4094 :
4095 : //-----------------------------------------------------------------------------
4096 : // Declaration of the IPDL type |struct OpImageSwap|
4097 : //
4098 : namespace mozilla {
4099 : namespace layers {
4100 : class OpImageSwap MOZ_FINAL
4101 : {
4102 : private:
4103 : typedef mozilla::layers::PLayerParent PLayerParent;
4104 : typedef mozilla::layers::PLayerChild PLayerChild;
4105 : typedef mozilla::layers::SharedImage SharedImage;
4106 :
4107 : public:
4108 : OpImageSwap();
4109 :
4110 0 : OpImageSwap(
4111 : PLayerParent* _layerParent,
4112 : PLayerChild* _layerChild,
4113 : const SharedImage& _newBackImage)
4114 0 : {
4115 0 : Init();
4116 0 : Assign(_layerParent, _layerChild, _newBackImage);
4117 0 : }
4118 :
4119 0 : OpImageSwap(const OpImageSwap& _o)
4120 0 : {
4121 0 : Init();
4122 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackImage());
4123 0 : }
4124 :
4125 : ~OpImageSwap();
4126 :
4127 : void
4128 0 : operator=(const OpImageSwap& _o)
4129 : {
4130 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackImage());
4131 0 : }
4132 :
4133 : bool
4134 : operator==(const OpImageSwap& _o) const;
4135 :
4136 : PLayerParent*&
4137 0 : layerParent()
4138 : {
4139 0 : return layerParent_;
4140 : }
4141 : PLayerParent*
4142 0 : layerParent() const
4143 : {
4144 0 : return layerParent_;
4145 : }
4146 :
4147 : PLayerChild*&
4148 0 : layerChild()
4149 : {
4150 0 : return layerChild_;
4151 : }
4152 : PLayerChild*
4153 0 : layerChild() const
4154 : {
4155 0 : return layerChild_;
4156 : }
4157 :
4158 : SharedImage&
4159 0 : newBackImage()
4160 : {
4161 0 : return newBackImage_;
4162 : }
4163 : const SharedImage&
4164 0 : newBackImage() const
4165 : {
4166 0 : return newBackImage_;
4167 : }
4168 :
4169 : private:
4170 : void
4171 : Init();
4172 :
4173 : void
4174 : Assign(
4175 : PLayerParent* _layerParent,
4176 : PLayerChild* _layerChild,
4177 : const SharedImage& _newBackImage);
4178 :
4179 : PLayerParent* layerParent_;
4180 : PLayerChild* layerChild_;
4181 : SharedImage newBackImage_;
4182 : };
4183 : } // namespace layers
4184 : } // namespace mozilla
4185 :
4186 : namespace mozilla {
4187 : namespace layers {
4188 : class PLayerParent;
4189 : } // namespace layers
4190 : } // namespace mozilla
4191 :
4192 : namespace mozilla {
4193 : namespace layers {
4194 : class PLayerChild;
4195 : } // namespace layers
4196 : } // namespace mozilla
4197 :
4198 : namespace mozilla {
4199 : namespace layers {
4200 : class OptionalThebesBuffer;
4201 : } // namespace layers
4202 : } // namespace mozilla
4203 :
4204 : //-----------------------------------------------------------------------------
4205 : // Declaration of the IPDL type |struct OpThebesBufferSwap|
4206 : //
4207 : namespace mozilla {
4208 : namespace layers {
4209 : class OpThebesBufferSwap MOZ_FINAL
4210 : {
4211 : private:
4212 : typedef mozilla::layers::PLayerParent PLayerParent;
4213 : typedef mozilla::layers::PLayerChild PLayerChild;
4214 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4215 :
4216 : public:
4217 : OpThebesBufferSwap();
4218 :
4219 0 : OpThebesBufferSwap(
4220 : PLayerParent* _layerParent,
4221 : PLayerChild* _layerChild,
4222 : const OptionalThebesBuffer& _newBackBuffer,
4223 : const nsIntRegion& _newValidRegion,
4224 : const OptionalThebesBuffer& _readOnlyFrontBuffer,
4225 : const nsIntRegion& _frontUpdatedRegion)
4226 0 : {
4227 0 : Init();
4228 0 : Assign(_layerParent, _layerChild, _newBackBuffer, _newValidRegion, _readOnlyFrontBuffer, _frontUpdatedRegion);
4229 0 : }
4230 :
4231 0 : OpThebesBufferSwap(const OpThebesBufferSwap& _o)
4232 0 : {
4233 0 : Init();
4234 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackBuffer(), (_o).newValidRegion(), (_o).readOnlyFrontBuffer(), (_o).frontUpdatedRegion());
4235 0 : }
4236 :
4237 : ~OpThebesBufferSwap();
4238 :
4239 : void
4240 0 : operator=(const OpThebesBufferSwap& _o)
4241 : {
4242 0 : Assign(const_cast<PLayerParent*>((_o).layerParent()), const_cast<PLayerChild*>((_o).layerChild()), (_o).newBackBuffer(), (_o).newValidRegion(), (_o).readOnlyFrontBuffer(), (_o).frontUpdatedRegion());
4243 0 : }
4244 :
4245 : bool
4246 : operator==(const OpThebesBufferSwap& _o) const;
4247 :
4248 : PLayerParent*&
4249 0 : layerParent()
4250 : {
4251 0 : return layerParent_;
4252 : }
4253 : PLayerParent*
4254 0 : layerParent() const
4255 : {
4256 0 : return layerParent_;
4257 : }
4258 :
4259 : PLayerChild*&
4260 0 : layerChild()
4261 : {
4262 0 : return layerChild_;
4263 : }
4264 : PLayerChild*
4265 0 : layerChild() const
4266 : {
4267 0 : return layerChild_;
4268 : }
4269 :
4270 : OptionalThebesBuffer&
4271 0 : newBackBuffer()
4272 : {
4273 0 : return newBackBuffer_;
4274 : }
4275 : const OptionalThebesBuffer&
4276 0 : newBackBuffer() const
4277 : {
4278 0 : return newBackBuffer_;
4279 : }
4280 :
4281 : nsIntRegion&
4282 0 : newValidRegion()
4283 : {
4284 0 : return newValidRegion_;
4285 : }
4286 : const nsIntRegion&
4287 0 : newValidRegion() const
4288 : {
4289 0 : return newValidRegion_;
4290 : }
4291 :
4292 : OptionalThebesBuffer&
4293 0 : readOnlyFrontBuffer()
4294 : {
4295 0 : return readOnlyFrontBuffer_;
4296 : }
4297 : const OptionalThebesBuffer&
4298 0 : readOnlyFrontBuffer() const
4299 : {
4300 0 : return readOnlyFrontBuffer_;
4301 : }
4302 :
4303 : nsIntRegion&
4304 0 : frontUpdatedRegion()
4305 : {
4306 0 : return frontUpdatedRegion_;
4307 : }
4308 : const nsIntRegion&
4309 0 : frontUpdatedRegion() const
4310 : {
4311 0 : return frontUpdatedRegion_;
4312 : }
4313 :
4314 : private:
4315 : void
4316 : Init();
4317 :
4318 : void
4319 : Assign(
4320 : PLayerParent* _layerParent,
4321 : PLayerChild* _layerChild,
4322 : const OptionalThebesBuffer& _newBackBuffer,
4323 : const nsIntRegion& _newValidRegion,
4324 : const OptionalThebesBuffer& _readOnlyFrontBuffer,
4325 : const nsIntRegion& _frontUpdatedRegion);
4326 :
4327 : PLayerParent* layerParent_;
4328 : PLayerChild* layerChild_;
4329 : OptionalThebesBuffer newBackBuffer_;
4330 : nsIntRegion newValidRegion_;
4331 : OptionalThebesBuffer readOnlyFrontBuffer_;
4332 : nsIntRegion frontUpdatedRegion_;
4333 : };
4334 : } // namespace layers
4335 : } // namespace mozilla
4336 :
4337 : namespace mozilla {
4338 : namespace layers {
4339 : class OpBufferSwap;
4340 : } // namespace layers
4341 : } // namespace mozilla
4342 : namespace mozilla {
4343 : namespace layers {
4344 : class OpThebesBufferSwap;
4345 : } // namespace layers
4346 : } // namespace mozilla
4347 : namespace mozilla {
4348 : namespace layers {
4349 : class OpImageSwap;
4350 : } // namespace layers
4351 : } // namespace mozilla
4352 :
4353 : //-----------------------------------------------------------------------------
4354 : // Declaration of the IPDL type |union EditReply|
4355 : //
4356 : namespace mozilla {
4357 : namespace layers {
4358 : class EditReply MOZ_FINAL
4359 : {
4360 : public:
4361 : enum Type {
4362 : T__None,
4363 : TOpBufferSwap = 1,
4364 : TOpThebesBufferSwap,
4365 : TOpImageSwap,
4366 : T__Last = TOpImageSwap
4367 : };
4368 :
4369 : private:
4370 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4371 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4372 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4373 : typedef OpBufferSwap OpBufferSwap__tdef;
4374 : typedef OpThebesBufferSwap OpThebesBufferSwap__tdef;
4375 : typedef OpImageSwap OpImageSwap__tdef;
4376 :
4377 : union Value {
4378 : char VOpBufferSwap[sizeof(OpBufferSwap)];
4379 : char VOpThebesBufferSwap[sizeof(OpThebesBufferSwap)];
4380 : char VOpImageSwap[sizeof(OpImageSwap)];
4381 : };
4382 :
4383 : OpBufferSwap*
4384 0 : ptr_OpBufferSwap()
4385 : {
4386 0 : return reinterpret_cast<OpBufferSwap*>((&((mValue).VOpBufferSwap)));
4387 : }
4388 : const OpBufferSwap* const
4389 0 : constptr_OpBufferSwap() const
4390 : {
4391 0 : return reinterpret_cast<const OpBufferSwap* const>((&((mValue).VOpBufferSwap)));
4392 : }
4393 : OpThebesBufferSwap*
4394 0 : ptr_OpThebesBufferSwap()
4395 : {
4396 0 : return reinterpret_cast<OpThebesBufferSwap*>((&((mValue).VOpThebesBufferSwap)));
4397 : }
4398 : const OpThebesBufferSwap* const
4399 0 : constptr_OpThebesBufferSwap() const
4400 : {
4401 0 : return reinterpret_cast<const OpThebesBufferSwap* const>((&((mValue).VOpThebesBufferSwap)));
4402 : }
4403 : OpImageSwap*
4404 0 : ptr_OpImageSwap()
4405 : {
4406 0 : return reinterpret_cast<OpImageSwap*>((&((mValue).VOpImageSwap)));
4407 : }
4408 : const OpImageSwap* const
4409 0 : constptr_OpImageSwap() const
4410 : {
4411 0 : return reinterpret_cast<const OpImageSwap* const>((&((mValue).VOpImageSwap)));
4412 : }
4413 :
4414 : bool
4415 : MaybeDestroy(Type aNewType);
4416 :
4417 : void
4418 0 : AssertSanity() const
4419 : {
4420 0 : NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
4421 0 : NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
4422 0 : }
4423 : void
4424 0 : AssertSanity(Type aType) const
4425 : {
4426 0 : AssertSanity();
4427 0 : NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
4428 0 : }
4429 :
4430 : public:
4431 0 : EditReply() :
4432 0 : mType(T__None)
4433 : {
4434 0 : }
4435 :
4436 : EditReply(const OpBufferSwap& aOther);
4437 :
4438 : EditReply(const OpThebesBufferSwap& aOther);
4439 :
4440 : EditReply(const OpImageSwap& aOther);
4441 :
4442 : EditReply(const EditReply& aOther);
4443 :
4444 : ~EditReply();
4445 :
4446 : Type
4447 0 : type() const
4448 : {
4449 0 : return mType;
4450 : }
4451 :
4452 : EditReply&
4453 : operator=(const OpBufferSwap& aRhs);
4454 :
4455 : EditReply&
4456 : operator=(const OpThebesBufferSwap& aRhs);
4457 :
4458 : EditReply&
4459 : operator=(const OpImageSwap& aRhs);
4460 :
4461 : EditReply&
4462 : operator=(const EditReply& aRhs);
4463 :
4464 : bool
4465 : operator==(const OpBufferSwap& aRhs) const;
4466 :
4467 : bool
4468 : operator==(const OpThebesBufferSwap& aRhs) const;
4469 :
4470 : bool
4471 : operator==(const OpImageSwap& aRhs) const;
4472 :
4473 : bool
4474 : operator==(const EditReply& aRhs) const;
4475 :
4476 : OpBufferSwap&
4477 0 : get_OpBufferSwap()
4478 : {
4479 0 : AssertSanity(TOpBufferSwap);
4480 0 : return (*(ptr_OpBufferSwap()));
4481 : }
4482 : const OpBufferSwap&
4483 0 : get_OpBufferSwap() const
4484 : {
4485 0 : AssertSanity(TOpBufferSwap);
4486 0 : return (*(constptr_OpBufferSwap()));
4487 : }
4488 : operator OpBufferSwap&()
4489 : {
4490 : return get_OpBufferSwap();
4491 : }
4492 : operator const OpBufferSwap&() const
4493 : {
4494 : return get_OpBufferSwap();
4495 : }
4496 :
4497 : OpThebesBufferSwap&
4498 0 : get_OpThebesBufferSwap()
4499 : {
4500 0 : AssertSanity(TOpThebesBufferSwap);
4501 0 : return (*(ptr_OpThebesBufferSwap()));
4502 : }
4503 : const OpThebesBufferSwap&
4504 0 : get_OpThebesBufferSwap() const
4505 : {
4506 0 : AssertSanity(TOpThebesBufferSwap);
4507 0 : return (*(constptr_OpThebesBufferSwap()));
4508 : }
4509 : operator OpThebesBufferSwap&()
4510 : {
4511 : return get_OpThebesBufferSwap();
4512 : }
4513 : operator const OpThebesBufferSwap&() const
4514 : {
4515 : return get_OpThebesBufferSwap();
4516 : }
4517 :
4518 : OpImageSwap&
4519 0 : get_OpImageSwap()
4520 : {
4521 0 : AssertSanity(TOpImageSwap);
4522 0 : return (*(ptr_OpImageSwap()));
4523 : }
4524 : const OpImageSwap&
4525 0 : get_OpImageSwap() const
4526 : {
4527 0 : AssertSanity(TOpImageSwap);
4528 0 : return (*(constptr_OpImageSwap()));
4529 : }
4530 : operator OpImageSwap&()
4531 : {
4532 : return get_OpImageSwap();
4533 : }
4534 : operator const OpImageSwap&() const
4535 : {
4536 : return get_OpImageSwap();
4537 : }
4538 :
4539 : private:
4540 : Value mValue;
4541 : Type mType;
4542 : };
4543 : } // namespace layers
4544 : } // namespace mozilla
4545 :
4546 : //-----------------------------------------------------------------------------
4547 : // Code common to PLayersChild and PLayersParent
4548 : //
4549 : namespace mozilla {
4550 : namespace layers {
4551 : namespace PLayers {
4552 :
4553 : enum State {
4554 : __Dead,
4555 : __Null,
4556 : __Error,
4557 : __Start = __Null
4558 : };
4559 :
4560 : enum MessageType {
4561 : PLayersStart = PLayersMsgStart << 16,
4562 : PLayersPreStart = (PLayersMsgStart << 16) - 1,
4563 : Msg_PLayerConstructor__ID,
4564 : Reply_PLayerConstructor__ID,
4565 : Msg_Update__ID,
4566 : Reply_Update__ID,
4567 : Msg___delete____ID,
4568 : Reply___delete____ID,
4569 : PLayersEnd
4570 : };
4571 :
4572 : bool
4573 : Transition(
4574 : State from,
4575 : mozilla::ipc::Trigger trigger,
4576 : State* next);
4577 :
4578 : class Msg_PLayerConstructor :
4579 : public IPC::Message
4580 0 : {
4581 : private:
4582 : typedef mozilla::ipc::ActorHandle ActorHandle;
4583 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4584 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4585 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4586 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4587 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4588 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4589 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4590 : typedef mozilla::layers::YUVImage YUVImage;
4591 : typedef mozilla::layers::SharedImage SharedImage;
4592 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4593 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4594 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4595 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4596 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4597 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4598 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4599 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4600 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4601 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4602 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4603 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4604 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4605 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4606 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4607 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4608 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4609 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4610 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4611 : typedef mozilla::layers::Edit Edit;
4612 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4613 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4614 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4615 : typedef mozilla::layers::EditReply EditReply;
4616 : typedef mozilla::ipc::Shmem Shmem;
4617 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4618 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4619 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4620 : typedef mozilla::null_t null_t;
4621 : typedef mozilla::WindowsHandle WindowsHandle;
4622 :
4623 : public:
4624 : enum {
4625 : ID = Msg_PLayerConstructor__ID
4626 : };
4627 0 : Msg_PLayerConstructor() :
4628 0 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Msg_PLayerConstructor")
4629 : {
4630 0 : }
4631 :
4632 : void
4633 0 : Log(
4634 : const std::string& __pfx,
4635 : FILE* __outf) const
4636 : {
4637 0 : std::string __logmsg;
4638 0 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4639 0 : (__logmsg).append(__pfx);
4640 0 : (__logmsg).append("Msg_PLayerConstructor(");
4641 :
4642 0 : (__logmsg).append("[TODO])\n");
4643 0 : fputs((__logmsg).c_str(), __outf);
4644 0 : }
4645 : };
4646 :
4647 : class Reply_PLayerConstructor :
4648 : public IPC::Message
4649 : {
4650 : private:
4651 : typedef mozilla::ipc::ActorHandle ActorHandle;
4652 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4653 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4654 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4655 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4656 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4657 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4658 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4659 : typedef mozilla::layers::YUVImage YUVImage;
4660 : typedef mozilla::layers::SharedImage SharedImage;
4661 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4662 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4663 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4664 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4665 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4666 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4667 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4668 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4669 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4670 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4671 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4672 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4673 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4674 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4675 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4676 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4677 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4678 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4679 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4680 : typedef mozilla::layers::Edit Edit;
4681 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4682 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4683 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4684 : typedef mozilla::layers::EditReply EditReply;
4685 : typedef mozilla::ipc::Shmem Shmem;
4686 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4687 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4688 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4689 : typedef mozilla::null_t null_t;
4690 : typedef mozilla::WindowsHandle WindowsHandle;
4691 :
4692 : public:
4693 : enum {
4694 : ID = Reply_PLayerConstructor__ID
4695 : };
4696 : Reply_PLayerConstructor() :
4697 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Reply_PLayerConstructor")
4698 : {
4699 : }
4700 :
4701 : void
4702 : Log(
4703 : const std::string& __pfx,
4704 : FILE* __outf) const
4705 : {
4706 : std::string __logmsg;
4707 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4708 : (__logmsg).append(__pfx);
4709 : (__logmsg).append("Reply_PLayerConstructor(");
4710 :
4711 : (__logmsg).append("[TODO])\n");
4712 : fputs((__logmsg).c_str(), __outf);
4713 : }
4714 : };
4715 :
4716 : class Msg_Update :
4717 : public IPC::Message
4718 0 : {
4719 : private:
4720 : typedef mozilla::ipc::ActorHandle ActorHandle;
4721 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4722 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4723 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4724 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4725 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4726 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4727 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4728 : typedef mozilla::layers::YUVImage YUVImage;
4729 : typedef mozilla::layers::SharedImage SharedImage;
4730 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4731 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4732 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4733 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4734 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4735 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4736 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4737 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4738 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4739 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4740 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4741 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4742 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4743 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4744 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4745 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4746 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4747 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4748 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4749 : typedef mozilla::layers::Edit Edit;
4750 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4751 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4752 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4753 : typedef mozilla::layers::EditReply EditReply;
4754 : typedef mozilla::ipc::Shmem Shmem;
4755 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4756 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4757 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4758 : typedef mozilla::null_t null_t;
4759 : typedef mozilla::WindowsHandle WindowsHandle;
4760 :
4761 : public:
4762 : enum {
4763 : ID = Msg_Update__ID
4764 : };
4765 0 : Msg_Update() :
4766 0 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Msg_Update")
4767 : {
4768 0 : }
4769 :
4770 : void
4771 0 : Log(
4772 : const std::string& __pfx,
4773 : FILE* __outf) const
4774 : {
4775 0 : std::string __logmsg;
4776 0 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4777 0 : (__logmsg).append(__pfx);
4778 0 : (__logmsg).append("Msg_Update(");
4779 :
4780 0 : (__logmsg).append("[TODO])\n");
4781 0 : fputs((__logmsg).c_str(), __outf);
4782 0 : }
4783 : };
4784 :
4785 : class Reply_Update :
4786 : public IPC::Message
4787 0 : {
4788 : private:
4789 : typedef mozilla::ipc::ActorHandle ActorHandle;
4790 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4791 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4792 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4793 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4794 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4795 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4796 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4797 : typedef mozilla::layers::YUVImage YUVImage;
4798 : typedef mozilla::layers::SharedImage SharedImage;
4799 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4800 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4801 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4802 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4803 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4804 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4805 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4806 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4807 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4808 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4809 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4810 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4811 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4812 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4813 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4814 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4815 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4816 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4817 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4818 : typedef mozilla::layers::Edit Edit;
4819 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4820 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4821 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4822 : typedef mozilla::layers::EditReply EditReply;
4823 : typedef mozilla::ipc::Shmem Shmem;
4824 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4825 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4826 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4827 : typedef mozilla::null_t null_t;
4828 : typedef mozilla::WindowsHandle WindowsHandle;
4829 :
4830 : public:
4831 : enum {
4832 : ID = Reply_Update__ID
4833 : };
4834 0 : Reply_Update() :
4835 0 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Reply_Update")
4836 : {
4837 0 : }
4838 :
4839 : void
4840 0 : Log(
4841 : const std::string& __pfx,
4842 : FILE* __outf) const
4843 : {
4844 0 : std::string __logmsg;
4845 0 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4846 0 : (__logmsg).append(__pfx);
4847 0 : (__logmsg).append("Reply_Update(");
4848 :
4849 0 : (__logmsg).append("[TODO])\n");
4850 0 : fputs((__logmsg).c_str(), __outf);
4851 0 : }
4852 : };
4853 :
4854 : class Msg___delete__ :
4855 : public IPC::Message
4856 0 : {
4857 : private:
4858 : typedef mozilla::ipc::ActorHandle ActorHandle;
4859 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4860 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4861 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4862 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4863 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4864 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4865 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4866 : typedef mozilla::layers::YUVImage YUVImage;
4867 : typedef mozilla::layers::SharedImage SharedImage;
4868 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4869 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4870 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4871 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4872 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4873 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4874 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4875 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4876 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4877 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4878 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4879 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4880 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4881 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4882 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4883 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4884 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4885 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4886 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4887 : typedef mozilla::layers::Edit Edit;
4888 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4889 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4890 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4891 : typedef mozilla::layers::EditReply EditReply;
4892 : typedef mozilla::ipc::Shmem Shmem;
4893 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4894 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4895 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4896 : typedef mozilla::null_t null_t;
4897 : typedef mozilla::WindowsHandle WindowsHandle;
4898 :
4899 : public:
4900 : enum {
4901 : ID = Msg___delete____ID
4902 : };
4903 0 : Msg___delete__() :
4904 0 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Msg___delete__")
4905 : {
4906 0 : }
4907 :
4908 : void
4909 0 : Log(
4910 : const std::string& __pfx,
4911 : FILE* __outf) const
4912 : {
4913 0 : std::string __logmsg;
4914 0 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4915 0 : (__logmsg).append(__pfx);
4916 0 : (__logmsg).append("Msg___delete__(");
4917 :
4918 0 : (__logmsg).append("[TODO])\n");
4919 0 : fputs((__logmsg).c_str(), __outf);
4920 0 : }
4921 : };
4922 :
4923 : class Reply___delete__ :
4924 : public IPC::Message
4925 : {
4926 : private:
4927 : typedef mozilla::ipc::ActorHandle ActorHandle;
4928 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
4929 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
4930 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
4931 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
4932 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
4933 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
4934 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
4935 : typedef mozilla::layers::YUVImage YUVImage;
4936 : typedef mozilla::layers::SharedImage SharedImage;
4937 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
4938 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
4939 : typedef mozilla::layers::CanvasSurface CanvasSurface;
4940 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
4941 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
4942 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
4943 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
4944 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
4945 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
4946 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
4947 : typedef mozilla::layers::LayerAttributes LayerAttributes;
4948 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
4949 : typedef mozilla::layers::OpSetRoot OpSetRoot;
4950 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
4951 : typedef mozilla::layers::OpAppendChild OpAppendChild;
4952 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
4953 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
4954 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
4955 : typedef mozilla::layers::OpPaintImage OpPaintImage;
4956 : typedef mozilla::layers::Edit Edit;
4957 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
4958 : typedef mozilla::layers::OpImageSwap OpImageSwap;
4959 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
4960 : typedef mozilla::layers::EditReply EditReply;
4961 : typedef mozilla::ipc::Shmem Shmem;
4962 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
4963 : typedef mozilla::layers::FrameMetrics FrameMetrics;
4964 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
4965 : typedef mozilla::null_t null_t;
4966 : typedef mozilla::WindowsHandle WindowsHandle;
4967 :
4968 : public:
4969 : enum {
4970 : ID = Reply___delete____ID
4971 : };
4972 : Reply___delete__() :
4973 : IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PLayers::Reply___delete__")
4974 : {
4975 : }
4976 :
4977 : void
4978 : Log(
4979 : const std::string& __pfx,
4980 : FILE* __outf) const
4981 : {
4982 : std::string __logmsg;
4983 : StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
4984 : (__logmsg).append(__pfx);
4985 : (__logmsg).append("Reply___delete__(");
4986 :
4987 : (__logmsg).append("[TODO])\n");
4988 : fputs((__logmsg).c_str(), __outf);
4989 : }
4990 : };
4991 :
4992 :
4993 :
4994 : } // namespace PLayers
4995 : } // namespace layers
4996 : } // namespace mozilla
4997 :
4998 : #endif // ifndef PLayers_h
|