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

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

Generated by: LCOV version 1.7