LCOV - code coverage report
Current view: directory - objdir/ipc/ipdl/_ipdlheaders/mozilla/layers - PLayers.h (source / functions) Found Hit Coverage
Test: app.info Lines: 1057 0 0.0 %
Date: 2012-06-02 Functions: 399 0 0.0 %

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

Generated by: LCOV version 1.7