LCOV - app.info - objdir/ipc/ipdl/PLayersParent.cpp

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

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

Generated by: LCOV version 1.7