LCOV - app.info - objdir/ipc/ipdl/_ipdlheaders/mozilla/layers/PLayers.h

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-07-07 | 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