LCOV - code coverage report
Current view: directory - objdir/ipc/ipdl - PLayers.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 1441 0 0.0 %
Date: 2012-06-02 Functions: 262 0 0.0 %

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

Generated by: LCOV version 1.7