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

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : 
       7                 : #include "mozilla/layers/PLayersParent.h"
       8                 : 
       9                 : #include "mozilla/layers/PCompositorParent.h"
      10                 : #include "mozilla/layers/PLayerParent.h"
      11                 : #include "mozilla/layout/PRenderFrameParent.h"
      12                 : 
      13                 : typedef IPC::Message Message;
      14                 : typedef mozilla::ipc::RPCChannel Channel;
      15                 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
      16                 : typedef base::ProcessHandle ProcessHandle;
      17                 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
      18                 : typedef mozilla::ipc::SharedMemory SharedMemory;
      19                 : typedef mozilla::ipc::Trigger Trigger;
      20                 : typedef mozilla::ipc::ActorHandle ActorHandle;
      21                 : typedef mozilla::layers::OpCreateThebesLayer OpCreateThebesLayer;
      22                 : typedef mozilla::layers::OpCreateContainerLayer OpCreateContainerLayer;
      23                 : typedef mozilla::layers::OpCreateImageLayer OpCreateImageLayer;
      24                 : typedef mozilla::layers::OpCreateColorLayer OpCreateColorLayer;
      25                 : typedef mozilla::layers::OpCreateCanvasLayer OpCreateCanvasLayer;
      26                 : typedef mozilla::layers::SurfaceDescriptorD3D10 SurfaceDescriptorD3D10;
      27                 : typedef mozilla::layers::SurfaceDescriptor SurfaceDescriptor;
      28                 : typedef mozilla::layers::YUVImage YUVImage;
      29                 : typedef mozilla::layers::SharedImage SharedImage;
      30                 : typedef mozilla::layers::ThebesBuffer ThebesBuffer;
      31                 : typedef mozilla::layers::OptionalThebesBuffer OptionalThebesBuffer;
      32                 : typedef mozilla::layers::CanvasSurface CanvasSurface;
      33                 : typedef mozilla::layers::CommonLayerAttributes CommonLayerAttributes;
      34                 : typedef mozilla::layers::ThebesLayerAttributes ThebesLayerAttributes;
      35                 : typedef mozilla::layers::ContainerLayerAttributes ContainerLayerAttributes;
      36                 : typedef mozilla::layers::ColorLayerAttributes ColorLayerAttributes;
      37                 : typedef mozilla::layers::CanvasLayerAttributes CanvasLayerAttributes;
      38                 : typedef mozilla::layers::ImageLayerAttributes ImageLayerAttributes;
      39                 : typedef mozilla::layers::SpecificLayerAttributes SpecificLayerAttributes;
      40                 : typedef mozilla::layers::LayerAttributes LayerAttributes;
      41                 : typedef mozilla::layers::OpSetLayerAttributes OpSetLayerAttributes;
      42                 : typedef mozilla::layers::OpSetRoot OpSetRoot;
      43                 : typedef mozilla::layers::OpInsertAfter OpInsertAfter;
      44                 : typedef mozilla::layers::OpAppendChild OpAppendChild;
      45                 : typedef mozilla::layers::OpRemoveChild OpRemoveChild;
      46                 : typedef mozilla::layers::OpPaintThebesBuffer OpPaintThebesBuffer;
      47                 : typedef mozilla::layers::OpPaintCanvas OpPaintCanvas;
      48                 : typedef mozilla::layers::OpPaintImage OpPaintImage;
      49                 : typedef mozilla::layers::Edit Edit;
      50                 : typedef mozilla::layers::OpBufferSwap OpBufferSwap;
      51                 : typedef mozilla::layers::OpImageSwap OpImageSwap;
      52                 : typedef mozilla::layers::OpThebesBufferSwap OpThebesBufferSwap;
      53                 : typedef mozilla::layers::EditReply EditReply;
      54                 : typedef mozilla::ipc::Shmem Shmem;
      55                 : typedef mozilla::GraphicsFilterType GraphicsFilterType;
      56                 : typedef mozilla::layers::FrameMetrics FrameMetrics;
      57                 : typedef mozilla::layers::SurfaceDescriptorX11 SurfaceDescriptorX11;
      58                 : typedef mozilla::null_t null_t;
      59                 : typedef mozilla::WindowsHandle WindowsHandle;
      60                 : using mozilla::layers::PCompositorParent;
      61                 : using mozilla::layers::PLayerParent;
      62                 : using mozilla::layout::PRenderFrameParent;
      63                 : 
      64                 : namespace mozilla {
      65                 : namespace layers {
      66                 : 
      67                 : 
      68                 : bool
      69               0 : PLayersParent::RecvPLayerConstructor(PLayerParent* actor)
      70                 : {
      71               0 :     return true;
      72                 : }
      73                 : 
      74                 : bool
      75               0 : PLayersParent::Recv__delete__()
      76                 : {
      77               0 :     return true;
      78                 : }
      79                 : 
      80                 : void
      81               0 : PLayersParent::ActorDestroy(ActorDestroyReason why)
      82                 : {
      83               0 : }
      84                 : 
      85               0 : PLayersParent::PLayersParent() :
      86                 :     mId(0),
      87               0 :     mState(PLayers::__Dead)
      88                 : {
      89               0 :     MOZ_COUNT_CTOR(PLayersParent);
      90               0 : }
      91                 : 
      92               0 : PLayersParent::~PLayersParent()
      93                 : {
      94               0 :     MOZ_COUNT_DTOR(PLayersParent);
      95               0 : }
      96                 : 
      97                 : void
      98               0 : PLayersParent::ManagedPLayerParent(InfallibleTArray<PLayerParent*>& aArr) const
      99                 : {
     100               0 :     aArr = mManagedPLayerParent;
     101               0 : }
     102                 : 
     103                 : const InfallibleTArray<PLayerParent*>&
     104               0 : PLayersParent::ManagedPLayerParent() const
     105                 : {
     106               0 :     return mManagedPLayerParent;
     107                 : }
     108                 : 
     109                 : PLayers::State
     110               0 : PLayersParent::state()
     111                 : {
     112               0 :     return mState;
     113                 : }
     114                 : 
     115                 : int32
     116               0 : PLayersParent::Register(ChannelListener* aRouted)
     117                 : {
     118               0 :     return (mManager)->Register(aRouted);
     119                 : }
     120                 : 
     121                 : int32
     122               0 : PLayersParent::RegisterID(
     123                 :         ChannelListener* aRouted,
     124                 :         int32 aId)
     125                 : {
     126               0 :     return (mManager)->RegisterID(aRouted, aId);
     127                 : }
     128                 : 
     129                 : ChannelListener*
     130               0 : PLayersParent::Lookup(int32 aId)
     131                 : {
     132               0 :     return (mManager)->Lookup(aId);
     133                 : }
     134                 : 
     135                 : void
     136               0 : PLayersParent::Unregister(int32 aId)
     137                 : {
     138               0 :     return (mManager)->Unregister(aId);
     139                 : }
     140                 : 
     141                 : void
     142               0 : PLayersParent::RemoveManagee(
     143                 :         int32 aProtocolId,
     144                 :         ChannelListener* aListener)
     145                 : {
     146               0 :     switch (aProtocolId) {
     147                 :     case PLayerMsgStart:
     148                 :         {
     149               0 :             PLayerParent* actor = static_cast<PLayerParent*>(aListener);
     150               0 :             NS_ABORT_IF_FALSE(((mManagedPLayerParent).NoIndex) != ((mManagedPLayerParent).BinaryIndexOf(actor)), "actor not managed by this!");
     151                 : 
     152               0 :             (mManagedPLayerParent).RemoveElementSorted(actor);
     153               0 :             DeallocPLayer(actor);
     154               0 :             return;
     155                 :         }
     156                 :     default:
     157                 :         {
     158               0 :             NS_RUNTIMEABORT("unreached");
     159               0 :             return;
     160                 :         }
     161                 :     }
     162                 : }
     163                 : 
     164                 : Shmem::SharedMemory*
     165               0 : PLayersParent::CreateSharedMemory(
     166                 :         size_t aSize,
     167                 :         Shmem::SharedMemory::SharedMemoryType type,
     168                 :         bool unsafe,
     169                 :         Shmem::id_t* aId)
     170                 : {
     171               0 :     return (mManager)->CreateSharedMemory(aSize, type, unsafe, aId);
     172                 : }
     173                 : 
     174                 : bool
     175               0 : PLayersParent::AdoptSharedMemory(
     176                 :         Shmem::SharedMemory* segment,
     177                 :         Shmem::id_t* aId)
     178                 : {
     179               0 :     return (mManager)->AdoptSharedMemory(segment, aId);
     180                 : }
     181                 : 
     182                 : Shmem::SharedMemory*
     183               0 : PLayersParent::LookupSharedMemory(Shmem::id_t aId)
     184                 : {
     185               0 :     return (mManager)->LookupSharedMemory(aId);
     186                 : }
     187                 : 
     188                 : bool
     189               0 : PLayersParent::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
     190                 : {
     191               0 :     return (mManager)->IsTrackingSharedMemory(segment);
     192                 : }
     193                 : 
     194                 : bool
     195               0 : PLayersParent::DestroySharedMemory(Shmem& aShmem)
     196                 : {
     197               0 :     return (mManager)->DestroySharedMemory(aShmem);
     198                 : }
     199                 : 
     200                 : ProcessHandle
     201               0 : PLayersParent::OtherProcess() const
     202                 : {
     203               0 :     return (mManager)->OtherProcess();
     204                 : }
     205                 : 
     206                 : AsyncChannel*
     207               0 : PLayersParent::GetIPCChannel()
     208                 : {
     209               0 :     return mChannel;
     210                 : }
     211                 : 
     212                 : PLayersParent::Result
     213               0 : PLayersParent::OnMessageReceived(const Message& __msg)
     214                 : {
     215               0 :     switch ((__msg).type()) {
     216                 :     case PLayers::Msg_PLayerConstructor__ID:
     217                 :         {
     218               0 :             (const_cast<Message&>(__msg)).set_name("PLayers::Msg_PLayerConstructor");
     219               0 :             if (mozilla::ipc::LoggingEnabled()) {
     220               0 :                 (static_cast<const PLayers::Msg_PLayerConstructor*>((&(__msg))))->Log("[PLayersParent] Received ", stderr);
     221                 :             }
     222                 : 
     223               0 :             void* __iter = 0;
     224                 :             ActorHandle __handle;
     225                 :             PLayerParent* actor;
     226                 : 
     227               0 :             if ((!(Read((&(__handle)), (&(__msg)), (&(__iter)))))) {
     228               0 :                 FatalError("error deserializing (better message TODO)");
     229               0 :                 return MsgValueError;
     230                 :             }
     231               0 :             (__msg).EndRead(__iter);
     232               0 :             if ((!(PLayers::Transition(mState, Trigger(Trigger::Recv, PLayers::Msg_PLayerConstructor__ID), (&(mState)))))) {
     233               0 :                 NS_WARNING("bad state transition!");
     234                 :             }
     235               0 :             actor = AllocPLayer();
     236               0 :             if ((!(actor))) {
     237               0 :                 return MsgValueError;
     238                 :             }
     239               0 :             (actor)->mId = RegisterID(actor, (__handle).mId);
     240               0 :             (actor)->mManager = this;
     241               0 :             (actor)->mChannel = mChannel;
     242               0 :             (mManagedPLayerParent).InsertElementSorted(actor);
     243               0 :             (actor)->mState = mozilla::layers::PLayer::__Start;
     244                 : 
     245               0 :             if ((!(RecvPLayerConstructor(actor)))) {
     246               0 :                 return MsgProcessingError;
     247                 :             }
     248                 : 
     249               0 :             return MsgProcessed;
     250                 :         }
     251                 :     case PLayers::Msg___delete____ID:
     252                 :         {
     253               0 :             (const_cast<Message&>(__msg)).set_name("PLayers::Msg___delete__");
     254               0 :             if (mozilla::ipc::LoggingEnabled()) {
     255               0 :                 (static_cast<const PLayers::Msg___delete__*>((&(__msg))))->Log("[PLayersParent] Received ", stderr);
     256                 :             }
     257                 : 
     258               0 :             void* __iter = 0;
     259                 :             PLayersParent* actor;
     260                 : 
     261               0 :             if ((!(Read((&(actor)), (&(__msg)), (&(__iter)), false)))) {
     262               0 :                 FatalError("error deserializing (better message TODO)");
     263               0 :                 return MsgValueError;
     264                 :             }
     265               0 :             (__msg).EndRead(__iter);
     266               0 :             if ((!(PLayers::Transition(mState, Trigger(Trigger::Recv, PLayers::Msg___delete____ID), (&(mState)))))) {
     267               0 :                 NS_WARNING("bad state transition!");
     268                 :             }
     269               0 :             if ((!(Recv__delete__()))) {
     270               0 :                 return MsgProcessingError;
     271                 :             }
     272                 : 
     273               0 :             (actor)->DestroySubtree(Deletion);
     274               0 :             (actor)->DeallocSubtree();
     275               0 :             ((actor)->mManager)->RemoveManagee(PLayersMsgStart, actor);
     276                 : 
     277                 : 
     278               0 :             return MsgProcessed;
     279                 :         }
     280                 :     default:
     281                 :         {
     282               0 :             return MsgNotKnown;
     283                 :         }
     284                 :     }
     285                 : }
     286                 : 
     287                 : PLayersParent::Result
     288               0 : PLayersParent::OnMessageReceived(
     289                 :         const Message& __msg,
     290                 :         Message*& __reply)
     291                 : {
     292               0 :     switch ((__msg).type()) {
     293                 :     case PLayers::Msg_Update__ID:
     294                 :         {
     295               0 :             (const_cast<Message&>(__msg)).set_name("PLayers::Msg_Update");
     296               0 :             if (mozilla::ipc::LoggingEnabled()) {
     297               0 :                 (static_cast<const PLayers::Msg_Update*>((&(__msg))))->Log("[PLayersParent] Received ", stderr);
     298                 :             }
     299                 : 
     300               0 :             void* __iter = 0;
     301               0 :             InfallibleTArray<Edit> cset;
     302                 : 
     303               0 :             if ((!(Read((&(cset)), (&(__msg)), (&(__iter)))))) {
     304               0 :                 FatalError("error deserializing (better message TODO)");
     305               0 :                 return MsgValueError;
     306                 :             }
     307               0 :             (__msg).EndRead(__iter);
     308               0 :             if ((!(PLayers::Transition(mState, Trigger(Trigger::Recv, PLayers::Msg_Update__ID), (&(mState)))))) {
     309               0 :                 NS_WARNING("bad state transition!");
     310                 :             }
     311               0 :             InfallibleTArray<EditReply> reply;
     312               0 :             int32 __id = mId;
     313               0 :             if ((!(RecvUpdate(cset, (&(reply)))))) {
     314               0 :                 return MsgProcessingError;
     315                 :             }
     316                 : 
     317               0 :             __reply = new PLayers::Reply_Update();
     318                 : 
     319               0 :             Write(reply, __reply);
     320               0 :             (__reply)->set_routing_id(__id);
     321               0 :             (__reply)->set_sync();
     322               0 :             (__reply)->set_reply();
     323                 : 
     324               0 :             if (mozilla::ipc::LoggingEnabled()) {
     325               0 :                 (static_cast<const PLayers::Reply_Update*>(__reply))->Log("[PLayersParent] Sending reply ", stderr);
     326                 :             }
     327               0 :             return MsgProcessed;
     328                 :         }
     329                 :     default:
     330                 :         {
     331               0 :             return MsgNotKnown;
     332                 :         }
     333                 :     }
     334                 : }
     335                 : 
     336                 : PLayersParent::Result
     337               0 : PLayersParent::OnCallReceived(
     338                 :         const Message& __msg,
     339                 :         Message*& __reply)
     340                 : {
     341               0 :     return MsgNotKnown;
     342                 : }
     343                 : 
     344                 : void
     345               0 : PLayersParent::OnProcessingError(Result code)
     346                 : {
     347               0 :     NS_RUNTIMEABORT("`OnProcessingError' called on non-toplevel actor");
     348               0 : }
     349                 : 
     350                 : bool
     351               0 : PLayersParent::OnReplyTimeout()
     352                 : {
     353               0 :     NS_RUNTIMEABORT("`OnReplyTimeout' called on non-toplevel actor");
     354               0 :     return false;
     355                 : }
     356                 : 
     357                 : void
     358               0 : PLayersParent::OnChannelClose()
     359                 : {
     360               0 :     NS_RUNTIMEABORT("`OnClose' called on non-toplevel actor");
     361               0 : }
     362                 : 
     363                 : void
     364               0 : PLayersParent::OnChannelError()
     365                 : {
     366               0 :     NS_RUNTIMEABORT("`OnError' called on non-toplevel actor");
     367               0 : }
     368                 : 
     369                 : void
     370               0 : PLayersParent::OnChannelConnected(int32 pid)
     371                 : {
     372               0 :     NS_RUNTIMEABORT("'OnConnected' called on non-toplevel actor");
     373               0 : }
     374                 : 
     375                 : bool
     376               0 : PLayersParent::AllocShmem(
     377                 :         size_t aSize,
     378                 :         Shmem::SharedMemory::SharedMemoryType aType,
     379                 :         Shmem* aMem)
     380                 : {
     381                 :     Shmem::id_t aId;
     382               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
     383               0 :     if ((!(rawmem))) {
     384               0 :         return false;
     385                 :     }
     386                 : 
     387               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     388               0 :     return true;
     389                 : }
     390                 : 
     391                 : bool
     392               0 : PLayersParent::AllocUnsafeShmem(
     393                 :         size_t aSize,
     394                 :         Shmem::SharedMemory::SharedMemoryType aType,
     395                 :         Shmem* aMem)
     396                 : {
     397                 :     Shmem::id_t aId;
     398               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
     399               0 :     if ((!(rawmem))) {
     400               0 :         return false;
     401                 :     }
     402                 : 
     403               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     404               0 :     return true;
     405                 : }
     406                 : 
     407                 : bool
     408               0 : PLayersParent::AdoptShmem(
     409                 :         Shmem& aMem,
     410                 :         Shmem* aOutMem)
     411                 : {
     412               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     413               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
     414               0 :         NS_RUNTIMEABORT("bad Shmem");
     415                 :     }
     416                 : 
     417                 :     Shmem::id_t aId;
     418               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
     419               0 :         return false;
     420                 :     }
     421                 : 
     422               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
     423               0 :     return true;
     424                 : }
     425                 : 
     426                 : bool
     427               0 : PLayersParent::DeallocShmem(Shmem& aMem)
     428                 : {
     429               0 :     bool ok = DestroySharedMemory(aMem);
     430               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     431               0 :     return ok;
     432                 : }
     433                 : 
     434                 : void
     435               0 : PLayersParent::FatalError(const char* const msg) const
     436                 : {
     437                 :     // Virtual method to prevent inlining.
     438                 :     // This give us better error reporting.
     439                 :     // See bug 589371
     440                 : 
     441               0 :     NS_ERROR("IPDL error:");
     442               0 :     NS_ERROR(msg);
     443                 : 
     444               0 :     NS_ERROR("[PLayersParent] killing child side as a result");
     445                 : 
     446               0 :     if ((!(base::KillProcess(OtherProcess(), base::PROCESS_END_KILLED_BY_USER, false)))) {
     447               0 :         NS_ERROR("  may have failed to kill child!");
     448                 :     }
     449               0 : }
     450                 : 
     451                 : void
     452               0 : PLayersParent::DestroySubtree(ActorDestroyReason why)
     453                 : {
     454                 :     // Unregister from our manager.
     455               0 :     Unregister(mId);
     456               0 :     mId = 1;
     457                 : 
     458               0 :     ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
     459                 : 
     460                 :     {
     461                 :         // Recursively shutting down PLayer kids
     462               0 :         InfallibleTArray<PLayerParent*> kids = mManagedPLayerParent;
     463               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     464               0 :             (kids[i])->DestroySubtree(subtreewhy);
     465                 :         }
     466                 :     }
     467                 : 
     468                 :     // Finally, destroy "us".
     469               0 :     ActorDestroy(why);
     470               0 : }
     471                 : 
     472                 : void
     473               0 : PLayersParent::DeallocSubtree()
     474                 : {
     475                 :     {
     476                 :         // Recursively deleting PLayer kids
     477               0 :         InfallibleTArray<PLayerParent*>& kids = mManagedPLayerParent;
     478               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     479               0 :             (kids[i])->DeallocSubtree();
     480                 :         }
     481                 : 
     482               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     483               0 :             DeallocPLayer(kids[i]);
     484                 :         }
     485               0 :         (mManagedPLayerParent).Clear();
     486                 :     }
     487               0 : }
     488                 : 
     489                 : void
     490               0 : PLayersParent::Write(
     491                 :         const OpAppendChild& __v,
     492                 :         Message* __msg)
     493                 : {
     494               0 :     Write((__v).containerParent(), __msg, false);
     495                 :     // skipping actor field that's meaningless on this side
     496               0 :     Write((__v).childLayerParent(), __msg, false);
     497                 :     // skipping actor field that's meaningless on this side
     498               0 : }
     499                 : 
     500                 : bool
     501               0 : PLayersParent::Read(
     502                 :         OpAppendChild* __v,
     503                 :         const Message* __msg,
     504                 :         void** __iter)
     505                 : {
     506               0 :     if ((!(Read((&((__v)->containerParent())), __msg, __iter, false)))) {
     507               0 :         return false;
     508                 :     }
     509                 :     // skipping actor field that's meaningless on this side
     510               0 :     if ((!(Read((&((__v)->childLayerParent())), __msg, __iter, false)))) {
     511               0 :         return false;
     512                 :     }
     513                 :     // skipping actor field that's meaningless on this side
     514               0 :     return true;
     515                 : }
     516                 : 
     517                 : void
     518               0 : PLayersParent::Write(
     519                 :         const SurfaceDescriptor& __v,
     520                 :         Message* __msg)
     521                 : {
     522                 :     typedef SurfaceDescriptor __type;
     523               0 :     Write(int((__v).type()), __msg);
     524                 : 
     525               0 :     switch ((__v).type()) {
     526                 :     case __type::TShmem:
     527                 :         {
     528               0 :             Write((__v).get_Shmem(), __msg);
     529               0 :             return;
     530                 :         }
     531                 :     case __type::TSurfaceDescriptorD3D10:
     532                 :         {
     533               0 :             Write((__v).get_SurfaceDescriptorD3D10(), __msg);
     534               0 :             return;
     535                 :         }
     536                 :     case __type::TSurfaceDescriptorX11:
     537                 :         {
     538               0 :             Write((__v).get_SurfaceDescriptorX11(), __msg);
     539               0 :             return;
     540                 :         }
     541                 :     default:
     542                 :         {
     543               0 :             NS_RUNTIMEABORT("unknown union type");
     544               0 :             return;
     545                 :         }
     546                 :     }
     547                 : }
     548                 : 
     549                 : bool
     550               0 : PLayersParent::Read(
     551                 :         SurfaceDescriptor* __v,
     552                 :         const Message* __msg,
     553                 :         void** __iter)
     554                 : {
     555                 :     typedef SurfaceDescriptor __type;
     556                 :     int type;
     557               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
     558               0 :         return false;
     559                 :     }
     560                 : 
     561               0 :     switch (type) {
     562                 :     case __type::TShmem:
     563                 :         {
     564               0 :             Shmem tmp = Shmem();
     565               0 :             (*(__v)) = tmp;
     566               0 :             return Read((&((__v)->get_Shmem())), __msg, __iter);
     567                 :         }
     568                 :     case __type::TSurfaceDescriptorD3D10:
     569                 :         {
     570               0 :             SurfaceDescriptorD3D10 tmp = SurfaceDescriptorD3D10();
     571               0 :             (*(__v)) = tmp;
     572               0 :             return Read((&((__v)->get_SurfaceDescriptorD3D10())), __msg, __iter);
     573                 :         }
     574                 :     case __type::TSurfaceDescriptorX11:
     575                 :         {
     576               0 :             SurfaceDescriptorX11 tmp = SurfaceDescriptorX11();
     577               0 :             (*(__v)) = tmp;
     578               0 :             return Read((&((__v)->get_SurfaceDescriptorX11())), __msg, __iter);
     579                 :         }
     580                 :     default:
     581                 :         {
     582               0 :             return false;
     583                 :         }
     584                 :     }
     585                 : }
     586                 : 
     587                 : void
     588               0 : PLayersParent::Write(
     589                 :         const OpInsertAfter& __v,
     590                 :         Message* __msg)
     591                 : {
     592               0 :     Write((__v).containerParent(), __msg, false);
     593                 :     // skipping actor field that's meaningless on this side
     594               0 :     Write((__v).childLayerParent(), __msg, false);
     595                 :     // skipping actor field that's meaningless on this side
     596               0 :     Write((__v).afterParent(), __msg, false);
     597                 :     // skipping actor field that's meaningless on this side
     598               0 : }
     599                 : 
     600                 : bool
     601               0 : PLayersParent::Read(
     602                 :         OpInsertAfter* __v,
     603                 :         const Message* __msg,
     604                 :         void** __iter)
     605                 : {
     606               0 :     if ((!(Read((&((__v)->containerParent())), __msg, __iter, false)))) {
     607               0 :         return false;
     608                 :     }
     609                 :     // skipping actor field that's meaningless on this side
     610               0 :     if ((!(Read((&((__v)->childLayerParent())), __msg, __iter, false)))) {
     611               0 :         return false;
     612                 :     }
     613                 :     // skipping actor field that's meaningless on this side
     614               0 :     if ((!(Read((&((__v)->afterParent())), __msg, __iter, false)))) {
     615               0 :         return false;
     616                 :     }
     617                 :     // skipping actor field that's meaningless on this side
     618               0 :     return true;
     619                 : }
     620                 : 
     621                 : void
     622               0 : PLayersParent::Write(
     623                 :         const OpPaintThebesBuffer& __v,
     624                 :         Message* __msg)
     625                 : {
     626               0 :     Write((__v).layerParent(), __msg, false);
     627                 :     // skipping actor field that's meaningless on this side
     628               0 :     Write((__v).newFrontBuffer(), __msg);
     629               0 :     Write((__v).updatedRegion(), __msg);
     630               0 : }
     631                 : 
     632                 : bool
     633               0 : PLayersParent::Read(
     634                 :         OpPaintThebesBuffer* __v,
     635                 :         const Message* __msg,
     636                 :         void** __iter)
     637                 : {
     638               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
     639               0 :         return false;
     640                 :     }
     641                 :     // skipping actor field that's meaningless on this side
     642               0 :     if ((!(Read((&((__v)->newFrontBuffer())), __msg, __iter)))) {
     643               0 :         return false;
     644                 :     }
     645               0 :     if ((!(Read((&((__v)->updatedRegion())), __msg, __iter)))) {
     646               0 :         return false;
     647                 :     }
     648               0 :     return true;
     649                 : }
     650                 : 
     651                 : void
     652               0 : PLayersParent::Write(
     653                 :         const OpCreateColorLayer& __v,
     654                 :         Message* __msg)
     655                 : {
     656               0 :     Write((__v).layerParent(), __msg, false);
     657                 :     // skipping actor field that's meaningless on this side
     658               0 : }
     659                 : 
     660                 : bool
     661               0 : PLayersParent::Read(
     662                 :         OpCreateColorLayer* __v,
     663                 :         const Message* __msg,
     664                 :         void** __iter)
     665                 : {
     666               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
     667               0 :         return false;
     668                 :     }
     669                 :     // skipping actor field that's meaningless on this side
     670               0 :     return true;
     671                 : }
     672                 : 
     673                 : void
     674               0 : PLayersParent::Write(
     675                 :         const CanvasLayerAttributes& __v,
     676                 :         Message* __msg)
     677                 : {
     678               0 :     Write((__v).filter(), __msg);
     679               0 : }
     680                 : 
     681                 : bool
     682               0 : PLayersParent::Read(
     683                 :         CanvasLayerAttributes* __v,
     684                 :         const Message* __msg,
     685                 :         void** __iter)
     686                 : {
     687               0 :     if ((!(Read((&((__v)->filter())), __msg, __iter)))) {
     688               0 :         return false;
     689                 :     }
     690               0 :     return true;
     691                 : }
     692                 : 
     693                 : void
     694               0 : PLayersParent::Write(
     695                 :         const ImageLayerAttributes& __v,
     696                 :         Message* __msg)
     697                 : {
     698               0 :     Write((__v).filter(), __msg);
     699               0 : }
     700                 : 
     701                 : bool
     702               0 : PLayersParent::Read(
     703                 :         ImageLayerAttributes* __v,
     704                 :         const Message* __msg,
     705                 :         void** __iter)
     706                 : {
     707               0 :     if ((!(Read((&((__v)->filter())), __msg, __iter)))) {
     708               0 :         return false;
     709                 :     }
     710               0 :     return true;
     711                 : }
     712                 : 
     713                 : void
     714               0 : PLayersParent::Write(
     715                 :         const YUVImage& __v,
     716                 :         Message* __msg)
     717                 : {
     718               0 :     Write((__v).Ydata(), __msg);
     719               0 :     Write((__v).Udata(), __msg);
     720               0 :     Write((__v).Vdata(), __msg);
     721               0 :     Write((__v).picture(), __msg);
     722               0 : }
     723                 : 
     724                 : bool
     725               0 : PLayersParent::Read(
     726                 :         YUVImage* __v,
     727                 :         const Message* __msg,
     728                 :         void** __iter)
     729                 : {
     730               0 :     if ((!(Read((&((__v)->Ydata())), __msg, __iter)))) {
     731               0 :         return false;
     732                 :     }
     733               0 :     if ((!(Read((&((__v)->Udata())), __msg, __iter)))) {
     734               0 :         return false;
     735                 :     }
     736               0 :     if ((!(Read((&((__v)->Vdata())), __msg, __iter)))) {
     737               0 :         return false;
     738                 :     }
     739               0 :     if ((!(Read((&((__v)->picture())), __msg, __iter)))) {
     740               0 :         return false;
     741                 :     }
     742               0 :     return true;
     743                 : }
     744                 : 
     745                 : void
     746               0 : PLayersParent::Write(
     747                 :         const CanvasSurface& __v,
     748                 :         Message* __msg)
     749                 : {
     750                 :     typedef CanvasSurface __type;
     751               0 :     Write(int((__v).type()), __msg);
     752                 : 
     753               0 :     switch ((__v).type()) {
     754                 :     case __type::TSurfaceDescriptor:
     755                 :         {
     756               0 :             Write((__v).get_SurfaceDescriptor(), __msg);
     757               0 :             return;
     758                 :         }
     759                 :     case __type::Tnull_t:
     760                 :         {
     761               0 :             Write((__v).get_null_t(), __msg);
     762               0 :             return;
     763                 :         }
     764                 :     default:
     765                 :         {
     766               0 :             NS_RUNTIMEABORT("unknown union type");
     767               0 :             return;
     768                 :         }
     769                 :     }
     770                 : }
     771                 : 
     772                 : bool
     773               0 : PLayersParent::Read(
     774                 :         CanvasSurface* __v,
     775                 :         const Message* __msg,
     776                 :         void** __iter)
     777                 : {
     778                 :     typedef CanvasSurface __type;
     779                 :     int type;
     780               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
     781               0 :         return false;
     782                 :     }
     783                 : 
     784               0 :     switch (type) {
     785                 :     case __type::TSurfaceDescriptor:
     786                 :         {
     787               0 :             SurfaceDescriptor tmp = SurfaceDescriptor();
     788               0 :             (*(__v)) = tmp;
     789               0 :             return Read((&((__v)->get_SurfaceDescriptor())), __msg, __iter);
     790                 :         }
     791                 :     case __type::Tnull_t:
     792                 :         {
     793               0 :             null_t tmp = null_t();
     794               0 :             (*(__v)) = tmp;
     795               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
     796                 :         }
     797                 :     default:
     798                 :         {
     799               0 :             return false;
     800                 :         }
     801                 :     }
     802                 : }
     803                 : 
     804                 : void
     805               0 : PLayersParent::Write(
     806                 :         PLayerParent* __v,
     807                 :         Message* __msg,
     808                 :         bool __nullable)
     809                 : {
     810                 :     int32 id;
     811               0 :     if ((!(__v))) {
     812               0 :         if ((!(__nullable))) {
     813               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
     814                 :         }
     815               0 :         id = 0;
     816                 :     }
     817                 :     else {
     818               0 :         id = (__v)->mId;
     819               0 :         if ((1) == (id)) {
     820               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
     821                 :         }
     822                 :     }
     823                 : 
     824               0 :     Write(id, __msg);
     825               0 : }
     826                 : 
     827                 : bool
     828               0 : PLayersParent::Read(
     829                 :         PLayerParent** __v,
     830                 :         const Message* __msg,
     831                 :         void** __iter,
     832                 :         bool __nullable)
     833                 : {
     834                 :     int32 id;
     835               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
     836               0 :         return false;
     837                 :     }
     838               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
     839               0 :         return false;
     840                 :     }
     841                 : 
     842               0 :     if ((0) == (id)) {
     843               0 :         (*(__v)) = 0;
     844                 :     }
     845                 :     else {
     846               0 :         (*(__v)) = static_cast<PLayerParent*>(Lookup(id));
     847               0 :         if ((!((*(__v))))) {
     848               0 :             return false;
     849                 :         }
     850                 :     }
     851               0 :     return true;
     852                 : }
     853                 : 
     854                 : void
     855               0 : PLayersParent::Write(
     856                 :         const OpCreateThebesLayer& __v,
     857                 :         Message* __msg)
     858                 : {
     859               0 :     Write((__v).layerParent(), __msg, false);
     860                 :     // skipping actor field that's meaningless on this side
     861               0 : }
     862                 : 
     863                 : bool
     864               0 : PLayersParent::Read(
     865                 :         OpCreateThebesLayer* __v,
     866                 :         const Message* __msg,
     867                 :         void** __iter)
     868                 : {
     869               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
     870               0 :         return false;
     871                 :     }
     872                 :     // skipping actor field that's meaningless on this side
     873               0 :     return true;
     874                 : }
     875                 : 
     876                 : void
     877               0 : PLayersParent::Write(
     878                 :         const EditReply& __v,
     879                 :         Message* __msg)
     880                 : {
     881                 :     typedef EditReply __type;
     882               0 :     Write(int((__v).type()), __msg);
     883                 : 
     884               0 :     switch ((__v).type()) {
     885                 :     case __type::TOpBufferSwap:
     886                 :         {
     887               0 :             Write((__v).get_OpBufferSwap(), __msg);
     888               0 :             return;
     889                 :         }
     890                 :     case __type::TOpThebesBufferSwap:
     891                 :         {
     892               0 :             Write((__v).get_OpThebesBufferSwap(), __msg);
     893               0 :             return;
     894                 :         }
     895                 :     case __type::TOpImageSwap:
     896                 :         {
     897               0 :             Write((__v).get_OpImageSwap(), __msg);
     898               0 :             return;
     899                 :         }
     900                 :     default:
     901                 :         {
     902               0 :             NS_RUNTIMEABORT("unknown union type");
     903               0 :             return;
     904                 :         }
     905                 :     }
     906                 : }
     907                 : 
     908                 : bool
     909               0 : PLayersParent::Read(
     910                 :         EditReply* __v,
     911                 :         const Message* __msg,
     912                 :         void** __iter)
     913                 : {
     914                 :     typedef EditReply __type;
     915                 :     int type;
     916               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
     917               0 :         return false;
     918                 :     }
     919                 : 
     920               0 :     switch (type) {
     921                 :     case __type::TOpBufferSwap:
     922                 :         {
     923               0 :             OpBufferSwap tmp = OpBufferSwap();
     924               0 :             (*(__v)) = tmp;
     925               0 :             return Read((&((__v)->get_OpBufferSwap())), __msg, __iter);
     926                 :         }
     927                 :     case __type::TOpThebesBufferSwap:
     928                 :         {
     929               0 :             OpThebesBufferSwap tmp = OpThebesBufferSwap();
     930               0 :             (*(__v)) = tmp;
     931               0 :             return Read((&((__v)->get_OpThebesBufferSwap())), __msg, __iter);
     932                 :         }
     933                 :     case __type::TOpImageSwap:
     934                 :         {
     935               0 :             OpImageSwap tmp = OpImageSwap();
     936               0 :             (*(__v)) = tmp;
     937               0 :             return Read((&((__v)->get_OpImageSwap())), __msg, __iter);
     938                 :         }
     939                 :     default:
     940                 :         {
     941               0 :             return false;
     942                 :         }
     943                 :     }
     944                 : }
     945                 : 
     946                 : void
     947               0 : PLayersParent::Write(
     948                 :         const InfallibleTArray<Edit>& __v,
     949                 :         Message* __msg)
     950                 : {
     951               0 :     uint32 length = (__v).Length();
     952               0 :     Write(length, __msg);
     953                 : 
     954               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
     955               0 :         Write(__v[i], __msg);
     956                 :     }
     957               0 : }
     958                 : 
     959                 : bool
     960               0 : PLayersParent::Read(
     961                 :         InfallibleTArray<Edit>* __v,
     962                 :         const Message* __msg,
     963                 :         void** __iter)
     964                 : {
     965               0 :     InfallibleTArray<Edit>& a = (*(__v));
     966                 :     uint32 length;
     967               0 :     if ((!(Read((&(length)), __msg, __iter)))) {
     968               0 :         return false;
     969                 :     }
     970                 : 
     971               0 :     (__v)->SetLength(length);
     972               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
     973               0 :         if ((!(Read((&(a[i])), __msg, __iter)))) {
     974               0 :             return false;
     975                 :         }
     976                 :     }
     977               0 :     return true;
     978                 : }
     979                 : 
     980                 : void
     981               0 : PLayersParent::Write(
     982                 :         const Edit& __v,
     983                 :         Message* __msg)
     984                 : {
     985                 :     typedef Edit __type;
     986               0 :     Write(int((__v).type()), __msg);
     987                 : 
     988               0 :     switch ((__v).type()) {
     989                 :     case __type::TOpCreateThebesLayer:
     990                 :         {
     991               0 :             Write((__v).get_OpCreateThebesLayer(), __msg);
     992               0 :             return;
     993                 :         }
     994                 :     case __type::TOpCreateContainerLayer:
     995                 :         {
     996               0 :             Write((__v).get_OpCreateContainerLayer(), __msg);
     997               0 :             return;
     998                 :         }
     999                 :     case __type::TOpCreateImageLayer:
    1000                 :         {
    1001               0 :             Write((__v).get_OpCreateImageLayer(), __msg);
    1002               0 :             return;
    1003                 :         }
    1004                 :     case __type::TOpCreateColorLayer:
    1005                 :         {
    1006               0 :             Write((__v).get_OpCreateColorLayer(), __msg);
    1007               0 :             return;
    1008                 :         }
    1009                 :     case __type::TOpCreateCanvasLayer:
    1010                 :         {
    1011               0 :             Write((__v).get_OpCreateCanvasLayer(), __msg);
    1012               0 :             return;
    1013                 :         }
    1014                 :     case __type::TOpSetLayerAttributes:
    1015                 :         {
    1016               0 :             Write((__v).get_OpSetLayerAttributes(), __msg);
    1017               0 :             return;
    1018                 :         }
    1019                 :     case __type::TOpSetRoot:
    1020                 :         {
    1021               0 :             Write((__v).get_OpSetRoot(), __msg);
    1022               0 :             return;
    1023                 :         }
    1024                 :     case __type::TOpInsertAfter:
    1025                 :         {
    1026               0 :             Write((__v).get_OpInsertAfter(), __msg);
    1027               0 :             return;
    1028                 :         }
    1029                 :     case __type::TOpAppendChild:
    1030                 :         {
    1031               0 :             Write((__v).get_OpAppendChild(), __msg);
    1032               0 :             return;
    1033                 :         }
    1034                 :     case __type::TOpRemoveChild:
    1035                 :         {
    1036               0 :             Write((__v).get_OpRemoveChild(), __msg);
    1037               0 :             return;
    1038                 :         }
    1039                 :     case __type::TOpPaintThebesBuffer:
    1040                 :         {
    1041               0 :             Write((__v).get_OpPaintThebesBuffer(), __msg);
    1042               0 :             return;
    1043                 :         }
    1044                 :     case __type::TOpPaintCanvas:
    1045                 :         {
    1046               0 :             Write((__v).get_OpPaintCanvas(), __msg);
    1047               0 :             return;
    1048                 :         }
    1049                 :     case __type::TOpPaintImage:
    1050                 :         {
    1051               0 :             Write((__v).get_OpPaintImage(), __msg);
    1052               0 :             return;
    1053                 :         }
    1054                 :     default:
    1055                 :         {
    1056               0 :             NS_RUNTIMEABORT("unknown union type");
    1057               0 :             return;
    1058                 :         }
    1059                 :     }
    1060                 : }
    1061                 : 
    1062                 : bool
    1063               0 : PLayersParent::Read(
    1064                 :         Edit* __v,
    1065                 :         const Message* __msg,
    1066                 :         void** __iter)
    1067                 : {
    1068                 :     typedef Edit __type;
    1069                 :     int type;
    1070               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
    1071               0 :         return false;
    1072                 :     }
    1073                 : 
    1074               0 :     switch (type) {
    1075                 :     case __type::TOpCreateThebesLayer:
    1076                 :         {
    1077               0 :             OpCreateThebesLayer tmp = OpCreateThebesLayer();
    1078               0 :             (*(__v)) = tmp;
    1079               0 :             return Read((&((__v)->get_OpCreateThebesLayer())), __msg, __iter);
    1080                 :         }
    1081                 :     case __type::TOpCreateContainerLayer:
    1082                 :         {
    1083               0 :             OpCreateContainerLayer tmp = OpCreateContainerLayer();
    1084               0 :             (*(__v)) = tmp;
    1085               0 :             return Read((&((__v)->get_OpCreateContainerLayer())), __msg, __iter);
    1086                 :         }
    1087                 :     case __type::TOpCreateImageLayer:
    1088                 :         {
    1089               0 :             OpCreateImageLayer tmp = OpCreateImageLayer();
    1090               0 :             (*(__v)) = tmp;
    1091               0 :             return Read((&((__v)->get_OpCreateImageLayer())), __msg, __iter);
    1092                 :         }
    1093                 :     case __type::TOpCreateColorLayer:
    1094                 :         {
    1095               0 :             OpCreateColorLayer tmp = OpCreateColorLayer();
    1096               0 :             (*(__v)) = tmp;
    1097               0 :             return Read((&((__v)->get_OpCreateColorLayer())), __msg, __iter);
    1098                 :         }
    1099                 :     case __type::TOpCreateCanvasLayer:
    1100                 :         {
    1101               0 :             OpCreateCanvasLayer tmp = OpCreateCanvasLayer();
    1102               0 :             (*(__v)) = tmp;
    1103               0 :             return Read((&((__v)->get_OpCreateCanvasLayer())), __msg, __iter);
    1104                 :         }
    1105                 :     case __type::TOpSetLayerAttributes:
    1106                 :         {
    1107               0 :             OpSetLayerAttributes tmp = OpSetLayerAttributes();
    1108               0 :             (*(__v)) = tmp;
    1109               0 :             return Read((&((__v)->get_OpSetLayerAttributes())), __msg, __iter);
    1110                 :         }
    1111                 :     case __type::TOpSetRoot:
    1112                 :         {
    1113               0 :             OpSetRoot tmp = OpSetRoot();
    1114               0 :             (*(__v)) = tmp;
    1115               0 :             return Read((&((__v)->get_OpSetRoot())), __msg, __iter);
    1116                 :         }
    1117                 :     case __type::TOpInsertAfter:
    1118                 :         {
    1119               0 :             OpInsertAfter tmp = OpInsertAfter();
    1120               0 :             (*(__v)) = tmp;
    1121               0 :             return Read((&((__v)->get_OpInsertAfter())), __msg, __iter);
    1122                 :         }
    1123                 :     case __type::TOpAppendChild:
    1124                 :         {
    1125               0 :             OpAppendChild tmp = OpAppendChild();
    1126               0 :             (*(__v)) = tmp;
    1127               0 :             return Read((&((__v)->get_OpAppendChild())), __msg, __iter);
    1128                 :         }
    1129                 :     case __type::TOpRemoveChild:
    1130                 :         {
    1131               0 :             OpRemoveChild tmp = OpRemoveChild();
    1132               0 :             (*(__v)) = tmp;
    1133               0 :             return Read((&((__v)->get_OpRemoveChild())), __msg, __iter);
    1134                 :         }
    1135                 :     case __type::TOpPaintThebesBuffer:
    1136                 :         {
    1137               0 :             OpPaintThebesBuffer tmp = OpPaintThebesBuffer();
    1138               0 :             (*(__v)) = tmp;
    1139               0 :             return Read((&((__v)->get_OpPaintThebesBuffer())), __msg, __iter);
    1140                 :         }
    1141                 :     case __type::TOpPaintCanvas:
    1142                 :         {
    1143               0 :             OpPaintCanvas tmp = OpPaintCanvas();
    1144               0 :             (*(__v)) = tmp;
    1145               0 :             return Read((&((__v)->get_OpPaintCanvas())), __msg, __iter);
    1146                 :         }
    1147                 :     case __type::TOpPaintImage:
    1148                 :         {
    1149               0 :             OpPaintImage tmp = OpPaintImage();
    1150               0 :             (*(__v)) = tmp;
    1151               0 :             return Read((&((__v)->get_OpPaintImage())), __msg, __iter);
    1152                 :         }
    1153                 :     default:
    1154                 :         {
    1155               0 :             return false;
    1156                 :         }
    1157                 :     }
    1158                 : }
    1159                 : 
    1160                 : void
    1161               0 : PLayersParent::Write(
    1162                 :         const SharedImage& __v,
    1163                 :         Message* __msg)
    1164                 : {
    1165                 :     typedef SharedImage __type;
    1166               0 :     Write(int((__v).type()), __msg);
    1167                 : 
    1168               0 :     switch ((__v).type()) {
    1169                 :     case __type::TSurfaceDescriptor:
    1170                 :         {
    1171               0 :             Write((__v).get_SurfaceDescriptor(), __msg);
    1172               0 :             return;
    1173                 :         }
    1174                 :     case __type::TYUVImage:
    1175                 :         {
    1176               0 :             Write((__v).get_YUVImage(), __msg);
    1177               0 :             return;
    1178                 :         }
    1179                 :     case __type::Tnull_t:
    1180                 :         {
    1181               0 :             Write((__v).get_null_t(), __msg);
    1182               0 :             return;
    1183                 :         }
    1184                 :     default:
    1185                 :         {
    1186               0 :             NS_RUNTIMEABORT("unknown union type");
    1187               0 :             return;
    1188                 :         }
    1189                 :     }
    1190                 : }
    1191                 : 
    1192                 : bool
    1193               0 : PLayersParent::Read(
    1194                 :         SharedImage* __v,
    1195                 :         const Message* __msg,
    1196                 :         void** __iter)
    1197                 : {
    1198                 :     typedef SharedImage __type;
    1199                 :     int type;
    1200               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
    1201               0 :         return false;
    1202                 :     }
    1203                 : 
    1204               0 :     switch (type) {
    1205                 :     case __type::TSurfaceDescriptor:
    1206                 :         {
    1207               0 :             SurfaceDescriptor tmp = SurfaceDescriptor();
    1208               0 :             (*(__v)) = tmp;
    1209               0 :             return Read((&((__v)->get_SurfaceDescriptor())), __msg, __iter);
    1210                 :         }
    1211                 :     case __type::TYUVImage:
    1212                 :         {
    1213               0 :             YUVImage tmp = YUVImage();
    1214               0 :             (*(__v)) = tmp;
    1215               0 :             return Read((&((__v)->get_YUVImage())), __msg, __iter);
    1216                 :         }
    1217                 :     case __type::Tnull_t:
    1218                 :         {
    1219               0 :             null_t tmp = null_t();
    1220               0 :             (*(__v)) = tmp;
    1221               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
    1222                 :         }
    1223                 :     default:
    1224                 :         {
    1225               0 :             return false;
    1226                 :         }
    1227                 :     }
    1228                 : }
    1229                 : 
    1230                 : void
    1231               0 : PLayersParent::Write(
    1232                 :         const OptionalThebesBuffer& __v,
    1233                 :         Message* __msg)
    1234                 : {
    1235                 :     typedef OptionalThebesBuffer __type;
    1236               0 :     Write(int((__v).type()), __msg);
    1237                 : 
    1238               0 :     switch ((__v).type()) {
    1239                 :     case __type::TThebesBuffer:
    1240                 :         {
    1241               0 :             Write((__v).get_ThebesBuffer(), __msg);
    1242               0 :             return;
    1243                 :         }
    1244                 :     case __type::Tnull_t:
    1245                 :         {
    1246               0 :             Write((__v).get_null_t(), __msg);
    1247               0 :             return;
    1248                 :         }
    1249                 :     default:
    1250                 :         {
    1251               0 :             NS_RUNTIMEABORT("unknown union type");
    1252               0 :             return;
    1253                 :         }
    1254                 :     }
    1255                 : }
    1256                 : 
    1257                 : bool
    1258               0 : PLayersParent::Read(
    1259                 :         OptionalThebesBuffer* __v,
    1260                 :         const Message* __msg,
    1261                 :         void** __iter)
    1262                 : {
    1263                 :     typedef OptionalThebesBuffer __type;
    1264                 :     int type;
    1265               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
    1266               0 :         return false;
    1267                 :     }
    1268                 : 
    1269               0 :     switch (type) {
    1270                 :     case __type::TThebesBuffer:
    1271                 :         {
    1272               0 :             ThebesBuffer tmp = ThebesBuffer();
    1273               0 :             (*(__v)) = tmp;
    1274               0 :             return Read((&((__v)->get_ThebesBuffer())), __msg, __iter);
    1275                 :         }
    1276                 :     case __type::Tnull_t:
    1277                 :         {
    1278               0 :             null_t tmp = null_t();
    1279               0 :             (*(__v)) = tmp;
    1280               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
    1281                 :         }
    1282                 :     default:
    1283                 :         {
    1284               0 :             return false;
    1285                 :         }
    1286                 :     }
    1287                 : }
    1288                 : 
    1289                 : void
    1290               0 : PLayersParent::Write(
    1291                 :         PLayersParent* __v,
    1292                 :         Message* __msg,
    1293                 :         bool __nullable)
    1294                 : {
    1295                 :     int32 id;
    1296               0 :     if ((!(__v))) {
    1297               0 :         if ((!(__nullable))) {
    1298               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    1299                 :         }
    1300               0 :         id = 0;
    1301                 :     }
    1302                 :     else {
    1303               0 :         id = (__v)->mId;
    1304               0 :         if ((1) == (id)) {
    1305               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    1306                 :         }
    1307                 :     }
    1308                 : 
    1309               0 :     Write(id, __msg);
    1310               0 : }
    1311                 : 
    1312                 : bool
    1313               0 : PLayersParent::Read(
    1314                 :         PLayersParent** __v,
    1315                 :         const Message* __msg,
    1316                 :         void** __iter,
    1317                 :         bool __nullable)
    1318                 : {
    1319                 :     int32 id;
    1320               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    1321               0 :         return false;
    1322                 :     }
    1323               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    1324               0 :         return false;
    1325                 :     }
    1326                 : 
    1327               0 :     if ((0) == (id)) {
    1328               0 :         (*(__v)) = 0;
    1329                 :     }
    1330                 :     else {
    1331               0 :         (*(__v)) = static_cast<PLayersParent*>(Lookup(id));
    1332               0 :         if ((!((*(__v))))) {
    1333               0 :             return false;
    1334                 :         }
    1335                 :     }
    1336               0 :     return true;
    1337                 : }
    1338                 : 
    1339                 : void
    1340               0 : PLayersParent::Write(
    1341                 :         const OpImageSwap& __v,
    1342                 :         Message* __msg)
    1343                 : {
    1344               0 :     Write((__v).layerParent(), __msg, false);
    1345                 :     // skipping actor field that's meaningless on this side
    1346               0 :     Write((__v).newBackImage(), __msg);
    1347               0 : }
    1348                 : 
    1349                 : bool
    1350               0 : PLayersParent::Read(
    1351                 :         OpImageSwap* __v,
    1352                 :         const Message* __msg,
    1353                 :         void** __iter)
    1354                 : {
    1355               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1356               0 :         return false;
    1357                 :     }
    1358                 :     // skipping actor field that's meaningless on this side
    1359               0 :     if ((!(Read((&((__v)->newBackImage())), __msg, __iter)))) {
    1360               0 :         return false;
    1361                 :     }
    1362               0 :     return true;
    1363                 : }
    1364                 : 
    1365                 : void
    1366               0 : PLayersParent::Write(
    1367                 :         const ColorLayerAttributes& __v,
    1368                 :         Message* __msg)
    1369                 : {
    1370               0 :     Write((__v).color(), __msg);
    1371               0 : }
    1372                 : 
    1373                 : bool
    1374               0 : PLayersParent::Read(
    1375                 :         ColorLayerAttributes* __v,
    1376                 :         const Message* __msg,
    1377                 :         void** __iter)
    1378                 : {
    1379               0 :     if ((!(Read((&((__v)->color())), __msg, __iter)))) {
    1380               0 :         return false;
    1381                 :     }
    1382               0 :     return true;
    1383                 : }
    1384                 : 
    1385                 : void
    1386               0 : PLayersParent::Write(
    1387                 :         const SurfaceDescriptorD3D10& __v,
    1388                 :         Message* __msg)
    1389                 : {
    1390               0 :     Write((__v).handle(), __msg);
    1391               0 : }
    1392                 : 
    1393                 : bool
    1394               0 : PLayersParent::Read(
    1395                 :         SurfaceDescriptorD3D10* __v,
    1396                 :         const Message* __msg,
    1397                 :         void** __iter)
    1398                 : {
    1399               0 :     if ((!(Read((&((__v)->handle())), __msg, __iter)))) {
    1400               0 :         return false;
    1401                 :     }
    1402               0 :     return true;
    1403                 : }
    1404                 : 
    1405                 : void
    1406               0 : PLayersParent::Write(
    1407                 :         const OpPaintCanvas& __v,
    1408                 :         Message* __msg)
    1409                 : {
    1410               0 :     Write((__v).layerParent(), __msg, false);
    1411                 :     // skipping actor field that's meaningless on this side
    1412               0 :     Write((__v).newFrontBuffer(), __msg);
    1413               0 :     Write((__v).needYFlip(), __msg);
    1414               0 : }
    1415                 : 
    1416                 : bool
    1417               0 : PLayersParent::Read(
    1418                 :         OpPaintCanvas* __v,
    1419                 :         const Message* __msg,
    1420                 :         void** __iter)
    1421                 : {
    1422               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1423               0 :         return false;
    1424                 :     }
    1425                 :     // skipping actor field that's meaningless on this side
    1426               0 :     if ((!(Read((&((__v)->newFrontBuffer())), __msg, __iter)))) {
    1427               0 :         return false;
    1428                 :     }
    1429               0 :     if ((!(Read((&((__v)->needYFlip())), __msg, __iter)))) {
    1430               0 :         return false;
    1431                 :     }
    1432               0 :     return true;
    1433                 : }
    1434                 : 
    1435                 : void
    1436               0 : PLayersParent::Write(
    1437                 :         Shmem& __v,
    1438                 :         Message* __msg)
    1439                 : {
    1440               0 :     IPC::WriteParam(__msg, __v);
    1441               0 :     (__v).RevokeRights(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1442               0 :     (__v).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1443               0 : }
    1444                 : 
    1445                 : bool
    1446               0 : PLayersParent::Read(
    1447                 :         Shmem* __v,
    1448                 :         const Message* __msg,
    1449                 :         void** __iter)
    1450                 : {
    1451               0 :     Shmem tmp;
    1452               0 :     if ((!(IPC::ReadParam(__msg, __iter, (&(tmp)))))) {
    1453               0 :         return false;
    1454                 :     }
    1455                 : 
    1456               0 :     Shmem::id_t shmemid = (tmp).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1457               0 :     Shmem::SharedMemory* rawmem = LookupSharedMemory(shmemid);
    1458               0 :     if (rawmem) {
    1459               0 :         (*(__v)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, shmemid);
    1460               0 :         return true;
    1461                 :     }
    1462               0 :     return false;
    1463                 : }
    1464                 : 
    1465                 : void
    1466               0 : PLayersParent::Write(
    1467                 :         const OpPaintImage& __v,
    1468                 :         Message* __msg)
    1469                 : {
    1470               0 :     Write((__v).layerParent(), __msg, false);
    1471                 :     // skipping actor field that's meaningless on this side
    1472               0 :     Write((__v).newFrontBuffer(), __msg);
    1473               0 : }
    1474                 : 
    1475                 : bool
    1476               0 : PLayersParent::Read(
    1477                 :         OpPaintImage* __v,
    1478                 :         const Message* __msg,
    1479                 :         void** __iter)
    1480                 : {
    1481               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1482               0 :         return false;
    1483                 :     }
    1484                 :     // skipping actor field that's meaningless on this side
    1485               0 :     if ((!(Read((&((__v)->newFrontBuffer())), __msg, __iter)))) {
    1486               0 :         return false;
    1487                 :     }
    1488               0 :     return true;
    1489                 : }
    1490                 : 
    1491                 : void
    1492               0 : PLayersParent::Write(
    1493                 :         const OpThebesBufferSwap& __v,
    1494                 :         Message* __msg)
    1495                 : {
    1496               0 :     Write((__v).layerParent(), __msg, false);
    1497                 :     // skipping actor field that's meaningless on this side
    1498               0 :     Write((__v).newBackBuffer(), __msg);
    1499               0 :     Write((__v).newValidRegion(), __msg);
    1500               0 :     Write((__v).readOnlyFrontBuffer(), __msg);
    1501               0 :     Write((__v).frontUpdatedRegion(), __msg);
    1502               0 : }
    1503                 : 
    1504                 : bool
    1505               0 : PLayersParent::Read(
    1506                 :         OpThebesBufferSwap* __v,
    1507                 :         const Message* __msg,
    1508                 :         void** __iter)
    1509                 : {
    1510               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1511               0 :         return false;
    1512                 :     }
    1513                 :     // skipping actor field that's meaningless on this side
    1514               0 :     if ((!(Read((&((__v)->newBackBuffer())), __msg, __iter)))) {
    1515               0 :         return false;
    1516                 :     }
    1517               0 :     if ((!(Read((&((__v)->newValidRegion())), __msg, __iter)))) {
    1518               0 :         return false;
    1519                 :     }
    1520               0 :     if ((!(Read((&((__v)->readOnlyFrontBuffer())), __msg, __iter)))) {
    1521               0 :         return false;
    1522                 :     }
    1523               0 :     if ((!(Read((&((__v)->frontUpdatedRegion())), __msg, __iter)))) {
    1524               0 :         return false;
    1525                 :     }
    1526               0 :     return true;
    1527                 : }
    1528                 : 
    1529                 : void
    1530               0 : PLayersParent::Write(
    1531                 :         const OpCreateContainerLayer& __v,
    1532                 :         Message* __msg)
    1533                 : {
    1534               0 :     Write((__v).layerParent(), __msg, false);
    1535                 :     // skipping actor field that's meaningless on this side
    1536               0 : }
    1537                 : 
    1538                 : bool
    1539               0 : PLayersParent::Read(
    1540                 :         OpCreateContainerLayer* __v,
    1541                 :         const Message* __msg,
    1542                 :         void** __iter)
    1543                 : {
    1544               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1545               0 :         return false;
    1546                 :     }
    1547                 :     // skipping actor field that's meaningless on this side
    1548               0 :     return true;
    1549                 : }
    1550                 : 
    1551                 : void
    1552               0 : PLayersParent::Write(
    1553                 :         const LayerAttributes& __v,
    1554                 :         Message* __msg)
    1555                 : {
    1556               0 :     Write((__v).common(), __msg);
    1557               0 :     Write((__v).specific(), __msg);
    1558               0 : }
    1559                 : 
    1560                 : bool
    1561               0 : PLayersParent::Read(
    1562                 :         LayerAttributes* __v,
    1563                 :         const Message* __msg,
    1564                 :         void** __iter)
    1565                 : {
    1566               0 :     if ((!(Read((&((__v)->common())), __msg, __iter)))) {
    1567               0 :         return false;
    1568                 :     }
    1569               0 :     if ((!(Read((&((__v)->specific())), __msg, __iter)))) {
    1570               0 :         return false;
    1571                 :     }
    1572               0 :     return true;
    1573                 : }
    1574                 : 
    1575                 : void
    1576               0 : PLayersParent::Write(
    1577                 :         const OpBufferSwap& __v,
    1578                 :         Message* __msg)
    1579                 : {
    1580               0 :     Write((__v).layerParent(), __msg, false);
    1581                 :     // skipping actor field that's meaningless on this side
    1582               0 :     Write((__v).newBackBuffer(), __msg);
    1583               0 : }
    1584                 : 
    1585                 : bool
    1586               0 : PLayersParent::Read(
    1587                 :         OpBufferSwap* __v,
    1588                 :         const Message* __msg,
    1589                 :         void** __iter)
    1590                 : {
    1591               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1592               0 :         return false;
    1593                 :     }
    1594                 :     // skipping actor field that's meaningless on this side
    1595               0 :     if ((!(Read((&((__v)->newBackBuffer())), __msg, __iter)))) {
    1596               0 :         return false;
    1597                 :     }
    1598               0 :     return true;
    1599                 : }
    1600                 : 
    1601                 : void
    1602               0 : PLayersParent::Write(
    1603                 :         const OpSetRoot& __v,
    1604                 :         Message* __msg)
    1605                 : {
    1606               0 :     Write((__v).rootParent(), __msg, false);
    1607                 :     // skipping actor field that's meaningless on this side
    1608               0 : }
    1609                 : 
    1610                 : bool
    1611               0 : PLayersParent::Read(
    1612                 :         OpSetRoot* __v,
    1613                 :         const Message* __msg,
    1614                 :         void** __iter)
    1615                 : {
    1616               0 :     if ((!(Read((&((__v)->rootParent())), __msg, __iter, false)))) {
    1617               0 :         return false;
    1618                 :     }
    1619                 :     // skipping actor field that's meaningless on this side
    1620               0 :     return true;
    1621                 : }
    1622                 : 
    1623                 : void
    1624               0 : PLayersParent::Write(
    1625                 :         const OpRemoveChild& __v,
    1626                 :         Message* __msg)
    1627                 : {
    1628               0 :     Write((__v).containerParent(), __msg, false);
    1629                 :     // skipping actor field that's meaningless on this side
    1630               0 :     Write((__v).childLayerParent(), __msg, false);
    1631                 :     // skipping actor field that's meaningless on this side
    1632               0 : }
    1633                 : 
    1634                 : bool
    1635               0 : PLayersParent::Read(
    1636                 :         OpRemoveChild* __v,
    1637                 :         const Message* __msg,
    1638                 :         void** __iter)
    1639                 : {
    1640               0 :     if ((!(Read((&((__v)->containerParent())), __msg, __iter, false)))) {
    1641               0 :         return false;
    1642                 :     }
    1643                 :     // skipping actor field that's meaningless on this side
    1644               0 :     if ((!(Read((&((__v)->childLayerParent())), __msg, __iter, false)))) {
    1645               0 :         return false;
    1646                 :     }
    1647                 :     // skipping actor field that's meaningless on this side
    1648               0 :     return true;
    1649                 : }
    1650                 : 
    1651                 : void
    1652               0 : PLayersParent::Write(
    1653                 :         const ContainerLayerAttributes& __v,
    1654                 :         Message* __msg)
    1655                 : {
    1656               0 :     Write((__v).metrics(), __msg);
    1657               0 : }
    1658                 : 
    1659                 : bool
    1660               0 : PLayersParent::Read(
    1661                 :         ContainerLayerAttributes* __v,
    1662                 :         const Message* __msg,
    1663                 :         void** __iter)
    1664                 : {
    1665               0 :     if ((!(Read((&((__v)->metrics())), __msg, __iter)))) {
    1666               0 :         return false;
    1667                 :     }
    1668               0 :     return true;
    1669                 : }
    1670                 : 
    1671                 : void
    1672               0 : PLayersParent::Write(
    1673                 :         const OpSetLayerAttributes& __v,
    1674                 :         Message* __msg)
    1675                 : {
    1676               0 :     Write((__v).layerParent(), __msg, false);
    1677                 :     // skipping actor field that's meaningless on this side
    1678               0 :     Write((__v).attrs(), __msg);
    1679               0 : }
    1680                 : 
    1681                 : bool
    1682               0 : PLayersParent::Read(
    1683                 :         OpSetLayerAttributes* __v,
    1684                 :         const Message* __msg,
    1685                 :         void** __iter)
    1686                 : {
    1687               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1688               0 :         return false;
    1689                 :     }
    1690                 :     // skipping actor field that's meaningless on this side
    1691               0 :     if ((!(Read((&((__v)->attrs())), __msg, __iter)))) {
    1692               0 :         return false;
    1693                 :     }
    1694               0 :     return true;
    1695                 : }
    1696                 : 
    1697                 : void
    1698               0 : PLayersParent::Write(
    1699                 :         const ThebesBuffer& __v,
    1700                 :         Message* __msg)
    1701                 : {
    1702               0 :     Write((__v).buffer(), __msg);
    1703               0 :     Write((__v).rect(), __msg);
    1704               0 :     Write((__v).rotation(), __msg);
    1705               0 : }
    1706                 : 
    1707                 : bool
    1708               0 : PLayersParent::Read(
    1709                 :         ThebesBuffer* __v,
    1710                 :         const Message* __msg,
    1711                 :         void** __iter)
    1712                 : {
    1713               0 :     if ((!(Read((&((__v)->buffer())), __msg, __iter)))) {
    1714               0 :         return false;
    1715                 :     }
    1716               0 :     if ((!(Read((&((__v)->rect())), __msg, __iter)))) {
    1717               0 :         return false;
    1718                 :     }
    1719               0 :     if ((!(Read((&((__v)->rotation())), __msg, __iter)))) {
    1720               0 :         return false;
    1721                 :     }
    1722               0 :     return true;
    1723                 : }
    1724                 : 
    1725                 : void
    1726               0 : PLayersParent::Write(
    1727                 :         const SpecificLayerAttributes& __v,
    1728                 :         Message* __msg)
    1729                 : {
    1730                 :     typedef SpecificLayerAttributes __type;
    1731               0 :     Write(int((__v).type()), __msg);
    1732                 : 
    1733               0 :     switch ((__v).type()) {
    1734                 :     case __type::Tnull_t:
    1735                 :         {
    1736               0 :             Write((__v).get_null_t(), __msg);
    1737               0 :             return;
    1738                 :         }
    1739                 :     case __type::TThebesLayerAttributes:
    1740                 :         {
    1741               0 :             Write((__v).get_ThebesLayerAttributes(), __msg);
    1742               0 :             return;
    1743                 :         }
    1744                 :     case __type::TContainerLayerAttributes:
    1745                 :         {
    1746               0 :             Write((__v).get_ContainerLayerAttributes(), __msg);
    1747               0 :             return;
    1748                 :         }
    1749                 :     case __type::TColorLayerAttributes:
    1750                 :         {
    1751               0 :             Write((__v).get_ColorLayerAttributes(), __msg);
    1752               0 :             return;
    1753                 :         }
    1754                 :     case __type::TCanvasLayerAttributes:
    1755                 :         {
    1756               0 :             Write((__v).get_CanvasLayerAttributes(), __msg);
    1757               0 :             return;
    1758                 :         }
    1759                 :     case __type::TImageLayerAttributes:
    1760                 :         {
    1761               0 :             Write((__v).get_ImageLayerAttributes(), __msg);
    1762               0 :             return;
    1763                 :         }
    1764                 :     default:
    1765                 :         {
    1766               0 :             NS_RUNTIMEABORT("unknown union type");
    1767               0 :             return;
    1768                 :         }
    1769                 :     }
    1770                 : }
    1771                 : 
    1772                 : bool
    1773               0 : PLayersParent::Read(
    1774                 :         SpecificLayerAttributes* __v,
    1775                 :         const Message* __msg,
    1776                 :         void** __iter)
    1777                 : {
    1778                 :     typedef SpecificLayerAttributes __type;
    1779                 :     int type;
    1780               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
    1781               0 :         return false;
    1782                 :     }
    1783                 : 
    1784               0 :     switch (type) {
    1785                 :     case __type::Tnull_t:
    1786                 :         {
    1787               0 :             null_t tmp = null_t();
    1788               0 :             (*(__v)) = tmp;
    1789               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
    1790                 :         }
    1791                 :     case __type::TThebesLayerAttributes:
    1792                 :         {
    1793               0 :             ThebesLayerAttributes tmp = ThebesLayerAttributes();
    1794               0 :             (*(__v)) = tmp;
    1795               0 :             return Read((&((__v)->get_ThebesLayerAttributes())), __msg, __iter);
    1796                 :         }
    1797                 :     case __type::TContainerLayerAttributes:
    1798                 :         {
    1799               0 :             ContainerLayerAttributes tmp = ContainerLayerAttributes();
    1800               0 :             (*(__v)) = tmp;
    1801               0 :             return Read((&((__v)->get_ContainerLayerAttributes())), __msg, __iter);
    1802                 :         }
    1803                 :     case __type::TColorLayerAttributes:
    1804                 :         {
    1805               0 :             ColorLayerAttributes tmp = ColorLayerAttributes();
    1806               0 :             (*(__v)) = tmp;
    1807               0 :             return Read((&((__v)->get_ColorLayerAttributes())), __msg, __iter);
    1808                 :         }
    1809                 :     case __type::TCanvasLayerAttributes:
    1810                 :         {
    1811               0 :             CanvasLayerAttributes tmp = CanvasLayerAttributes();
    1812               0 :             (*(__v)) = tmp;
    1813               0 :             return Read((&((__v)->get_CanvasLayerAttributes())), __msg, __iter);
    1814                 :         }
    1815                 :     case __type::TImageLayerAttributes:
    1816                 :         {
    1817               0 :             ImageLayerAttributes tmp = ImageLayerAttributes();
    1818               0 :             (*(__v)) = tmp;
    1819               0 :             return Read((&((__v)->get_ImageLayerAttributes())), __msg, __iter);
    1820                 :         }
    1821                 :     default:
    1822                 :         {
    1823               0 :             return false;
    1824                 :         }
    1825                 :     }
    1826                 : }
    1827                 : 
    1828                 : void
    1829               0 : PLayersParent::Write(
    1830                 :         const ThebesLayerAttributes& __v,
    1831                 :         Message* __msg)
    1832                 : {
    1833               0 :     Write((__v).validRegion(), __msg);
    1834               0 : }
    1835                 : 
    1836                 : bool
    1837               0 : PLayersParent::Read(
    1838                 :         ThebesLayerAttributes* __v,
    1839                 :         const Message* __msg,
    1840                 :         void** __iter)
    1841                 : {
    1842               0 :     if ((!(Read((&((__v)->validRegion())), __msg, __iter)))) {
    1843               0 :         return false;
    1844                 :     }
    1845               0 :     return true;
    1846                 : }
    1847                 : 
    1848                 : void
    1849               0 : PLayersParent::Write(
    1850                 :         const InfallibleTArray<EditReply>& __v,
    1851                 :         Message* __msg)
    1852                 : {
    1853               0 :     uint32 length = (__v).Length();
    1854               0 :     Write(length, __msg);
    1855                 : 
    1856               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
    1857               0 :         Write(__v[i], __msg);
    1858                 :     }
    1859               0 : }
    1860                 : 
    1861                 : bool
    1862               0 : PLayersParent::Read(
    1863                 :         InfallibleTArray<EditReply>* __v,
    1864                 :         const Message* __msg,
    1865                 :         void** __iter)
    1866                 : {
    1867               0 :     InfallibleTArray<EditReply>& a = (*(__v));
    1868                 :     uint32 length;
    1869               0 :     if ((!(Read((&(length)), __msg, __iter)))) {
    1870               0 :         return false;
    1871                 :     }
    1872                 : 
    1873               0 :     (__v)->SetLength(length);
    1874               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
    1875               0 :         if ((!(Read((&(a[i])), __msg, __iter)))) {
    1876               0 :             return false;
    1877                 :         }
    1878                 :     }
    1879               0 :     return true;
    1880                 : }
    1881                 : 
    1882                 : void
    1883               0 : PLayersParent::Write(
    1884                 :         const OpCreateImageLayer& __v,
    1885                 :         Message* __msg)
    1886                 : {
    1887               0 :     Write((__v).layerParent(), __msg, false);
    1888                 :     // skipping actor field that's meaningless on this side
    1889               0 : }
    1890                 : 
    1891                 : bool
    1892               0 : PLayersParent::Read(
    1893                 :         OpCreateImageLayer* __v,
    1894                 :         const Message* __msg,
    1895                 :         void** __iter)
    1896                 : {
    1897               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1898               0 :         return false;
    1899                 :     }
    1900                 :     // skipping actor field that's meaningless on this side
    1901               0 :     return true;
    1902                 : }
    1903                 : 
    1904                 : void
    1905               0 : PLayersParent::Write(
    1906                 :         const CommonLayerAttributes& __v,
    1907                 :         Message* __msg)
    1908                 : {
    1909               0 :     Write((__v).visibleRegion(), __msg);
    1910               0 :     Write((__v).transform(), __msg);
    1911               0 :     Write((__v).contentFlags(), __msg);
    1912               0 :     Write((__v).opacity(), __msg);
    1913               0 :     Write((__v).useClipRect(), __msg);
    1914               0 :     Write((__v).clipRect(), __msg);
    1915               0 :     Write((__v).useTileSourceRect(), __msg);
    1916               0 :     Write((__v).tileSourceRect(), __msg);
    1917               0 :     Write((__v).isFixedPosition(), __msg);
    1918               0 : }
    1919                 : 
    1920                 : bool
    1921               0 : PLayersParent::Read(
    1922                 :         CommonLayerAttributes* __v,
    1923                 :         const Message* __msg,
    1924                 :         void** __iter)
    1925                 : {
    1926               0 :     if ((!(Read((&((__v)->visibleRegion())), __msg, __iter)))) {
    1927               0 :         return false;
    1928                 :     }
    1929               0 :     if ((!(Read((&((__v)->transform())), __msg, __iter)))) {
    1930               0 :         return false;
    1931                 :     }
    1932               0 :     if ((!(Read((&((__v)->contentFlags())), __msg, __iter)))) {
    1933               0 :         return false;
    1934                 :     }
    1935               0 :     if ((!(Read((&((__v)->opacity())), __msg, __iter)))) {
    1936               0 :         return false;
    1937                 :     }
    1938               0 :     if ((!(Read((&((__v)->useClipRect())), __msg, __iter)))) {
    1939               0 :         return false;
    1940                 :     }
    1941               0 :     if ((!(Read((&((__v)->clipRect())), __msg, __iter)))) {
    1942               0 :         return false;
    1943                 :     }
    1944               0 :     if ((!(Read((&((__v)->useTileSourceRect())), __msg, __iter)))) {
    1945               0 :         return false;
    1946                 :     }
    1947               0 :     if ((!(Read((&((__v)->tileSourceRect())), __msg, __iter)))) {
    1948               0 :         return false;
    1949                 :     }
    1950               0 :     if ((!(Read((&((__v)->isFixedPosition())), __msg, __iter)))) {
    1951               0 :         return false;
    1952                 :     }
    1953               0 :     return true;
    1954                 : }
    1955                 : 
    1956                 : void
    1957               0 : PLayersParent::Write(
    1958                 :         const OpCreateCanvasLayer& __v,
    1959                 :         Message* __msg)
    1960                 : {
    1961               0 :     Write((__v).layerParent(), __msg, false);
    1962                 :     // skipping actor field that's meaningless on this side
    1963               0 : }
    1964                 : 
    1965                 : bool
    1966               0 : PLayersParent::Read(
    1967                 :         OpCreateCanvasLayer* __v,
    1968                 :         const Message* __msg,
    1969                 :         void** __iter)
    1970                 : {
    1971               0 :     if ((!(Read((&((__v)->layerParent())), __msg, __iter, false)))) {
    1972               0 :         return false;
    1973                 :     }
    1974                 :     // skipping actor field that's meaningless on this side
    1975               0 :     return true;
    1976                 : }
    1977                 : 
    1978                 : 
    1979                 : 
    1980                 : } // namespace layers
    1981                 : } // namespace mozilla

Generated by: LCOV version 1.7