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

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : 
       7                 : #include "mozilla/layers/PCompositorChild.h"
       8                 : #ifdef MOZ_CRASHREPORTER
       9                 : #  include "nsXULAppAPI.h"
      10                 : #endif 
      11                 : 
      12                 : #include "mozilla/layers/PLayersChild.h"
      13                 : 
      14                 : typedef IPC::Message Message;
      15                 : typedef mozilla::ipc::RPCChannel Channel;
      16                 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
      17                 : typedef base::ProcessHandle ProcessHandle;
      18                 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
      19                 : typedef mozilla::ipc::SharedMemory SharedMemory;
      20                 : typedef mozilla::ipc::Trigger Trigger;
      21                 : typedef mozilla::ipc::ActorHandle ActorHandle;
      22                 : typedef mozilla::ipc::Shmem Shmem;
      23                 : typedef mozilla::LayersBackend LayersBackend;
      24                 : typedef mozilla::null_t null_t;
      25                 : using mozilla::layers::PLayersChild;
      26                 : 
      27                 : namespace mozilla {
      28                 : namespace layers {
      29                 : 
      30                 : 
      31                 : void
      32               0 : PCompositorChild::ActorDestroy(ActorDestroyReason why)
      33                 : {
      34               0 : }
      35                 : 
      36                 : void
      37               0 : PCompositorChild::ProcessingError(Result code)
      38                 : {
      39               0 : }
      40                 : 
      41                 : bool
      42               0 : PCompositorChild::ShouldContinueFromReplyTimeout()
      43                 : {
      44               0 :     return true;
      45                 : }
      46                 : 
      47                 : void
      48               0 : PCompositorChild::EnteredCxxStack()
      49                 : {
      50               0 : }
      51                 : 
      52                 : void
      53               0 : PCompositorChild::ExitedCxxStack()
      54                 : {
      55               0 : }
      56                 : 
      57                 : void
      58               0 : PCompositorChild::EnteredCall()
      59                 : {
      60               0 : }
      61                 : 
      62                 : void
      63               0 : PCompositorChild::ExitedCall()
      64                 : {
      65               0 : }
      66                 : 
      67               0 : PCompositorChild::PCompositorChild() :
      68                 :     mChannel(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
      69                 :     mLastRouteId(0),
      70                 :     mLastShmemId(0),
      71               0 :     mState(PCompositor::__Start)
      72                 : {
      73               0 :     MOZ_COUNT_CTOR(PCompositorChild);
      74               0 : }
      75                 : 
      76               0 : PCompositorChild::~PCompositorChild()
      77                 : {
      78               0 :     MOZ_COUNT_DTOR(PCompositorChild);
      79               0 : }
      80                 : 
      81                 : bool
      82               0 : PCompositorChild::Open(
      83                 :         Channel::Transport* aTransport,
      84                 :         ProcessHandle aOtherProcess,
      85                 :         MessageLoop* aThread,
      86                 :         AsyncChannel::Side aSide)
      87                 : {
      88               0 :     mOtherProcess = aOtherProcess;
      89               0 :     return (mChannel).Open(aTransport, aThread, aSide);
      90                 : }
      91                 : 
      92                 : bool
      93               0 : PCompositorChild::Open(
      94                 :         AsyncChannel* aChannel,
      95                 :         MessageLoop* aMessageLoop,
      96                 :         AsyncChannel::Side aSide)
      97                 : {
      98               0 :     mOtherProcess = 0;
      99               0 :     return (mChannel).Open(aChannel, aMessageLoop, aSide);
     100                 : }
     101                 : 
     102                 : void
     103               0 : PCompositorChild::Close()
     104                 : {
     105               0 :     (mChannel).Close();
     106               0 : }
     107                 : 
     108                 : void
     109               0 : PCompositorChild::SetReplyTimeoutMs(int32 aTimeoutMs)
     110                 : {
     111               0 :     (mChannel).SetReplyTimeoutMs(aTimeoutMs);
     112               0 : }
     113                 : 
     114                 : void
     115               0 : PCompositorChild::ManagedPLayersChild(InfallibleTArray<PLayersChild*>& aArr) const
     116                 : {
     117               0 :     aArr = mManagedPLayersChild;
     118               0 : }
     119                 : 
     120                 : const InfallibleTArray<PLayersChild*>&
     121               0 : PCompositorChild::ManagedPLayersChild() const
     122                 : {
     123               0 :     return mManagedPLayersChild;
     124                 : }
     125                 : 
     126                 : PCompositor::State
     127               0 : PCompositorChild::state()
     128                 : {
     129               0 :     return mState;
     130                 : }
     131                 : 
     132                 : bool
     133               0 : PCompositorChild::SendStop()
     134                 : {
     135               0 :     PCompositor::Msg_Stop* __msg = new PCompositor::Msg_Stop();
     136                 : 
     137                 : 
     138               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     139               0 :     (__msg)->set_sync();
     140                 : 
     141                 : 
     142               0 :     Message __reply;
     143                 : 
     144               0 :     if (mozilla::ipc::LoggingEnabled()) {
     145               0 :         (__msg)->Log("[PCompositorChild] Sending ", stderr);
     146                 :     }
     147               0 :     if ((!(PCompositor::Transition(mState, Trigger(Trigger::Recv, PCompositor::Msg_Stop__ID), (&(mState)))))) {
     148               0 :         NS_WARNING("bad state transition!");
     149                 :     }
     150                 : 
     151               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     152               0 :     if ((!(__sendok))) {
     153               0 :         return false;
     154                 :     }
     155                 : 
     156               0 :     if (mozilla::ipc::LoggingEnabled()) {
     157               0 :         (static_cast<const PCompositor::Reply_Stop*>((&(__reply))))->Log("[PCompositorChild] Received reply ", stderr);
     158                 :     }
     159                 : 
     160               0 :     return true;
     161                 : }
     162                 : 
     163                 : PLayersChild*
     164               0 : PCompositorChild::SendPLayersConstructor(const LayersBackend& backend)
     165                 : {
     166               0 :     return SendPLayersConstructor(AllocPLayers(backend), backend);
     167                 : }
     168                 : 
     169                 : PLayersChild*
     170               0 : PCompositorChild::SendPLayersConstructor(
     171                 :         PLayersChild* actor,
     172                 :         const LayersBackend& backend)
     173                 : {
     174               0 :     if ((!(actor))) {
     175               0 :         return 0;
     176                 :     }
     177               0 :     (actor)->mId = Register(actor);
     178               0 :     (actor)->mManager = this;
     179               0 :     (actor)->mChannel = (&(mChannel));
     180               0 :     (mManagedPLayersChild).InsertElementSorted(actor);
     181               0 :     (actor)->mState = mozilla::layers::PLayers::__Start;
     182                 : 
     183               0 :     PCompositor::Msg_PLayersConstructor* __msg = new PCompositor::Msg_PLayersConstructor();
     184                 : 
     185               0 :     Write(actor, __msg, false);
     186               0 :     Write(backend, __msg);
     187                 : 
     188               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     189               0 :     (__msg)->set_sync();
     190                 : 
     191                 : 
     192               0 :     Message __reply;
     193                 : 
     194               0 :     if (mozilla::ipc::LoggingEnabled()) {
     195               0 :         (__msg)->Log("[PCompositorChild] Sending ", stderr);
     196                 :     }
     197               0 :     if ((!(PCompositor::Transition(mState, Trigger(Trigger::Recv, PCompositor::Msg_PLayersConstructor__ID), (&(mState)))))) {
     198               0 :         NS_WARNING("bad state transition!");
     199                 :     }
     200                 : 
     201               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     202               0 :     if ((!(__sendok))) {
     203               0 :         (actor)->DestroySubtree(FailedConstructor);
     204               0 :         (actor)->DeallocSubtree();
     205               0 :         ((actor)->mManager)->RemoveManagee(PLayersMsgStart, actor);
     206               0 :         return 0;
     207                 :     }
     208                 : 
     209               0 :     if (mozilla::ipc::LoggingEnabled()) {
     210               0 :         (static_cast<const PCompositor::Reply_PLayersConstructor*>((&(__reply))))->Log("[PCompositorChild] Received reply ", stderr);
     211                 :     }
     212               0 :     return actor;
     213                 : }
     214                 : 
     215                 : int32
     216               0 : PCompositorChild::Register(ChannelListener* aRouted)
     217                 : {
     218               0 :     int32 tmp = (--(mLastRouteId));
     219               0 :     (mActorMap).AddWithID(aRouted, tmp);
     220               0 :     return tmp;
     221                 : }
     222                 : 
     223                 : int32
     224               0 : PCompositorChild::RegisterID(
     225                 :         ChannelListener* aRouted,
     226                 :         int32 aId)
     227                 : {
     228               0 :     (mActorMap).AddWithID(aRouted, aId);
     229               0 :     return aId;
     230                 : }
     231                 : 
     232                 : ChannelListener*
     233               0 : PCompositorChild::Lookup(int32 aId)
     234                 : {
     235               0 :     return (mActorMap).Lookup(aId);
     236                 : }
     237                 : 
     238                 : void
     239               0 : PCompositorChild::Unregister(int32 aId)
     240                 : {
     241               0 :     return (mActorMap).Remove(aId);
     242                 : }
     243                 : 
     244                 : void
     245               0 : PCompositorChild::RemoveManagee(
     246                 :         int32 aProtocolId,
     247                 :         ChannelListener* aListener)
     248                 : {
     249               0 :     switch (aProtocolId) {
     250                 :     case PLayersMsgStart:
     251                 :         {
     252               0 :             PLayersChild* actor = static_cast<PLayersChild*>(aListener);
     253               0 :             NS_ABORT_IF_FALSE(((mManagedPLayersChild).NoIndex) != ((mManagedPLayersChild).BinaryIndexOf(actor)), "actor not managed by this!");
     254                 : 
     255               0 :             (mManagedPLayersChild).RemoveElementSorted(actor);
     256               0 :             DeallocPLayers(actor);
     257               0 :             return;
     258                 :         }
     259                 :     default:
     260                 :         {
     261               0 :             NS_RUNTIMEABORT("unreached");
     262               0 :             return;
     263                 :         }
     264                 :     }
     265                 : }
     266                 : 
     267                 : Shmem::SharedMemory*
     268               0 : PCompositorChild::CreateSharedMemory(
     269                 :         size_t aSize,
     270                 :         Shmem::SharedMemory::SharedMemoryType type,
     271                 :         bool unsafe,
     272                 :         Shmem::id_t* aId)
     273                 : {
     274               0 :     nsAutoPtr<Shmem::SharedMemory> segment(Shmem::Alloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), aSize, type, unsafe));
     275               0 :     if ((!(segment))) {
     276               0 :         return 0;
     277                 :     }
     278                 :     Shmem aShmem(
     279                 :             Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(),
     280                 :             (segment).get(),
     281               0 :             (--(mLastShmemId)));
     282               0 :     Message* descriptor = (aShmem).ShareTo(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
     283               0 :     if ((!(descriptor))) {
     284               0 :         return 0;
     285                 :     }
     286               0 :     if ((!((mChannel).Send(descriptor)))) {
     287                 :     }
     288               0 :     (*(aId)) = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     289               0 :     (mShmemMap).AddWithID(segment, (*(aId)));
     290               0 :     return (segment).forget();
     291                 : }
     292                 : 
     293                 : bool
     294               0 : PCompositorChild::AdoptSharedMemory(
     295                 :         Shmem::SharedMemory* segment,
     296                 :         Shmem::id_t* aId)
     297                 : {
     298                 :     Shmem aShmem(
     299                 :             Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(),
     300                 :             segment,
     301               0 :             (--(mLastShmemId)));
     302               0 :     Message* descriptor = (aShmem).ShareTo(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
     303               0 :     if ((!(descriptor))) {
     304               0 :         return false;
     305                 :     }
     306               0 :     if ((!((mChannel).Send(descriptor)))) {
     307                 :     }
     308               0 :     (*(aId)) = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     309               0 :     (mShmemMap).AddWithID(segment, (*(aId)));
     310               0 :     (segment)->AddRef();
     311               0 :     return true;
     312                 : }
     313                 : 
     314                 : Shmem::SharedMemory*
     315               0 : PCompositorChild::LookupSharedMemory(Shmem::id_t aId)
     316                 : {
     317               0 :     return (mShmemMap).Lookup(aId);
     318                 : }
     319                 : 
     320                 : bool
     321               0 : PCompositorChild::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
     322                 : {
     323               0 :     return (mShmemMap).HasData(segment);
     324                 : }
     325                 : 
     326                 : bool
     327               0 : PCompositorChild::DestroySharedMemory(Shmem& aShmem)
     328                 : {
     329               0 :     Shmem::id_t aId = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     330               0 :     Shmem::SharedMemory* segment = LookupSharedMemory(aId);
     331               0 :     if ((!(segment))) {
     332               0 :         return false;
     333                 :     }
     334               0 :     Message* descriptor = (aShmem).UnshareFrom(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
     335                 : 
     336               0 :     (mShmemMap).Remove(aId);
     337               0 :     Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), segment);
     338                 : 
     339               0 :     return (descriptor) && ((mChannel).Send(descriptor));
     340                 : }
     341                 : 
     342                 : ProcessHandle
     343               0 : PCompositorChild::OtherProcess() const
     344                 : {
     345               0 :     return mOtherProcess;
     346                 : }
     347                 : 
     348                 : AsyncChannel*
     349               0 : PCompositorChild::GetIPCChannel()
     350                 : {
     351               0 :     return (&(mChannel));
     352                 : }
     353                 : 
     354                 : PCompositorChild::Result
     355               0 : PCompositorChild::OnMessageReceived(const Message& __msg)
     356                 : {
     357               0 :     int32 __route = (__msg).routing_id();
     358               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
     359               0 :         ChannelListener* __routed = Lookup(__route);
     360               0 :         if ((!(__routed))) {
     361               0 :             return MsgRouteError;
     362                 :         }
     363               0 :         return (__routed)->OnMessageReceived(__msg);
     364                 :     }
     365                 : 
     366               0 :     switch ((__msg).type()) {
     367                 :     default:
     368                 :         {
     369               0 :             return MsgNotKnown;
     370                 :         }
     371                 :     case SHMEM_CREATED_MESSAGE_TYPE:
     372                 :         {
     373                 :             Shmem::id_t id;
     374               0 :             nsAutoPtr<Shmem::SharedMemory> rawmem(Shmem::OpenExisting(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), __msg, (&(id)), true));
     375               0 :             if ((!(rawmem))) {
     376               0 :                 return MsgPayloadError;
     377                 :             }
     378               0 :             (mShmemMap).AddWithID((rawmem).forget(), id);
     379                 : 
     380               0 :             return MsgProcessed;
     381                 :         }
     382                 :     case SHMEM_DESTROYED_MESSAGE_TYPE:
     383                 :         {
     384                 :             Shmem::id_t id;
     385               0 :             void* iter = 0;
     386               0 :             if ((!(IPC::ReadParam((&(__msg)), (&(iter)), (&(id)))))) {
     387               0 :                 return MsgPayloadError;
     388                 :             }
     389               0 :             (__msg).EndRead(iter);
     390                 : 
     391               0 :             Shmem::SharedMemory* rawmem = LookupSharedMemory(id);
     392               0 :             if ((!(rawmem))) {
     393               0 :                 return MsgValueError;
     394                 :             }
     395               0 :             (mShmemMap).Remove(id);
     396               0 :             Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem);
     397               0 :             return MsgProcessed;
     398                 :         }
     399                 :     }
     400                 : }
     401                 : 
     402                 : PCompositorChild::Result
     403               0 : PCompositorChild::OnMessageReceived(
     404                 :         const Message& __msg,
     405                 :         Message*& __reply)
     406                 : {
     407               0 :     int32 __route = (__msg).routing_id();
     408               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
     409               0 :         ChannelListener* __routed = Lookup(__route);
     410               0 :         if ((!(__routed))) {
     411               0 :             return MsgRouteError;
     412                 :         }
     413               0 :         return (__routed)->OnMessageReceived(__msg, __reply);
     414                 :     }
     415                 : 
     416               0 :     return MsgNotKnown;
     417                 : }
     418                 : 
     419                 : PCompositorChild::Result
     420               0 : PCompositorChild::OnCallReceived(
     421                 :         const Message& __msg,
     422                 :         Message*& __reply)
     423                 : {
     424               0 :     int32 __route = (__msg).routing_id();
     425               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
     426               0 :         ChannelListener* __routed = Lookup(__route);
     427               0 :         if ((!(__routed))) {
     428               0 :             return MsgRouteError;
     429                 :         }
     430               0 :         return (__routed)->OnCallReceived(__msg, __reply);
     431                 :     }
     432                 : 
     433               0 :     return MsgNotKnown;
     434                 : }
     435                 : 
     436                 : void
     437               0 : PCompositorChild::OnProcessingError(Result code)
     438                 : {
     439               0 :     return ProcessingError(code);
     440                 : }
     441                 : 
     442                 : bool
     443               0 : PCompositorChild::OnReplyTimeout()
     444                 : {
     445               0 :     return ShouldContinueFromReplyTimeout();
     446                 : }
     447                 : 
     448                 : void
     449               0 : PCompositorChild::OnEnteredCxxStack()
     450                 : {
     451               0 :     return EnteredCxxStack();
     452                 : }
     453                 : 
     454                 : void
     455               0 : PCompositorChild::OnExitedCxxStack()
     456                 : {
     457               0 :     return ExitedCxxStack();
     458                 : }
     459                 : 
     460                 : void
     461               0 : PCompositorChild::OnEnteredCall()
     462                 : {
     463               0 :     return EnteredCall();
     464                 : }
     465                 : 
     466                 : void
     467               0 : PCompositorChild::OnExitedCall()
     468                 : {
     469               0 :     return ExitedCall();
     470                 : }
     471                 : 
     472                 : bool
     473               0 : PCompositorChild::IsOnCxxStack() const
     474                 : {
     475               0 :     return (mChannel).IsOnCxxStack();
     476                 : }
     477                 : 
     478                 : void
     479               0 : PCompositorChild::FlushPendingRPCQueue()
     480                 : {
     481               0 :     ((this)->mChannel).FlushPendingRPCQueue();
     482               0 : }
     483                 : 
     484                 : void
     485               0 : PCompositorChild::OnChannelClose()
     486                 : {
     487               0 :     DestroySubtree(NormalShutdown);
     488               0 :     DeallocSubtree();
     489               0 :     DeallocShmems();
     490               0 : }
     491                 : 
     492                 : void
     493               0 : PCompositorChild::OnChannelError()
     494                 : {
     495               0 :     DestroySubtree(AbnormalShutdown);
     496               0 :     DeallocSubtree();
     497               0 :     DeallocShmems();
     498               0 : }
     499                 : 
     500                 : void
     501               0 : PCompositorChild::OnChannelConnected(int32 pid)
     502                 : {
     503               0 : }
     504                 : 
     505                 : bool
     506               0 : PCompositorChild::AllocShmem(
     507                 :         size_t aSize,
     508                 :         Shmem::SharedMemory::SharedMemoryType aType,
     509                 :         Shmem* aMem)
     510                 : {
     511                 :     Shmem::id_t aId;
     512               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
     513               0 :     if ((!(rawmem))) {
     514               0 :         return false;
     515                 :     }
     516                 : 
     517               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     518               0 :     return true;
     519                 : }
     520                 : 
     521                 : bool
     522               0 : PCompositorChild::AllocUnsafeShmem(
     523                 :         size_t aSize,
     524                 :         Shmem::SharedMemory::SharedMemoryType aType,
     525                 :         Shmem* aMem)
     526                 : {
     527                 :     Shmem::id_t aId;
     528               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
     529               0 :     if ((!(rawmem))) {
     530               0 :         return false;
     531                 :     }
     532                 : 
     533               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     534               0 :     return true;
     535                 : }
     536                 : 
     537                 : bool
     538               0 : PCompositorChild::AdoptShmem(
     539                 :         Shmem& aMem,
     540                 :         Shmem* aOutMem)
     541                 : {
     542               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     543               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
     544               0 :         NS_RUNTIMEABORT("bad Shmem");
     545                 :     }
     546                 : 
     547                 :     Shmem::id_t aId;
     548               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
     549               0 :         return false;
     550                 :     }
     551                 : 
     552               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
     553               0 :     return true;
     554                 : }
     555                 : 
     556                 : bool
     557               0 : PCompositorChild::DeallocShmem(Shmem& aMem)
     558                 : {
     559               0 :     bool ok = DestroySharedMemory(aMem);
     560               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     561               0 :     return ok;
     562                 : }
     563                 : 
     564                 : void
     565               0 : PCompositorChild::ProcessNativeEventsInRPCCall()
     566                 : {
     567                 : #ifdef OS_WIN
     568                 :     (mChannel).ProcessNativeEventsInRPCCall();
     569                 : #else 
     570               0 :     NS_RUNTIMEABORT("This method is Windows-only");
     571                 : #endif 
     572               0 : }
     573                 : 
     574                 : void
     575               0 : PCompositorChild::FatalError(const char* const msg) const
     576                 : {
     577                 :     // Virtual method to prevent inlining.
     578                 :     // This give us better error reporting.
     579                 :     // See bug 589371
     580                 : 
     581               0 :     NS_ERROR("IPDL error:");
     582               0 :     NS_ERROR(msg);
     583                 : 
     584               0 :     NS_RUNTIMEABORT("[PCompositorChild] abort()ing as a result");
     585               0 : }
     586                 : 
     587                 : void
     588               0 : PCompositorChild::DestroySubtree(ActorDestroyReason why)
     589                 : {
     590               0 :     ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
     591                 : 
     592                 :     {
     593                 :         // Recursively shutting down PLayers kids
     594               0 :         InfallibleTArray<PLayersChild*> kids = mManagedPLayersChild;
     595               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     596               0 :             (kids[i])->DestroySubtree(subtreewhy);
     597                 :         }
     598                 :     }
     599                 : 
     600                 :     // Finally, destroy "us".
     601               0 :     ActorDestroy(why);
     602               0 : }
     603                 : 
     604                 : void
     605               0 : PCompositorChild::DeallocSubtree()
     606                 : {
     607                 :     {
     608                 :         // Recursively deleting PLayers kids
     609               0 :         InfallibleTArray<PLayersChild*>& kids = mManagedPLayersChild;
     610               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     611               0 :             (kids[i])->DeallocSubtree();
     612                 :         }
     613                 : 
     614               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
     615               0 :             DeallocPLayers(kids[i]);
     616                 :         }
     617               0 :         (mManagedPLayersChild).Clear();
     618                 :     }
     619               0 : }
     620                 : 
     621                 : void
     622               0 : PCompositorChild::DeallocShmems()
     623                 : {
     624               0 :     for (IDMap<SharedMemory>::const_iterator cit = (mShmemMap).begin(); (cit) != ((mShmemMap).end()); (++(cit))) {
     625               0 :         Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (cit)->second);
     626                 :     }
     627               0 :     (mShmemMap).Clear();
     628               0 : }
     629                 : 
     630                 : void
     631               0 : PCompositorChild::Write(
     632                 :         PLayersChild* __v,
     633                 :         Message* __msg,
     634                 :         bool __nullable)
     635                 : {
     636                 :     int32 id;
     637               0 :     if ((!(__v))) {
     638               0 :         if ((!(__nullable))) {
     639               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
     640                 :         }
     641               0 :         id = 0;
     642                 :     }
     643                 :     else {
     644               0 :         id = (__v)->mId;
     645               0 :         if ((1) == (id)) {
     646               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
     647                 :         }
     648                 :     }
     649                 : 
     650               0 :     Write(id, __msg);
     651               0 : }
     652                 : 
     653                 : bool
     654               0 : PCompositorChild::Read(
     655                 :         PLayersChild** __v,
     656                 :         const Message* __msg,
     657                 :         void** __iter,
     658                 :         bool __nullable)
     659                 : {
     660                 :     int32 id;
     661               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
     662               0 :         return false;
     663                 :     }
     664               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
     665               0 :         return false;
     666                 :     }
     667                 : 
     668               0 :     if ((0) == (id)) {
     669               0 :         (*(__v)) = 0;
     670                 :     }
     671                 :     else {
     672               0 :         (*(__v)) = static_cast<PLayersChild*>(Lookup(id));
     673               0 :         if ((!((*(__v))))) {
     674               0 :             return false;
     675                 :         }
     676                 :     }
     677               0 :     return true;
     678                 : }
     679                 : 
     680                 : 
     681                 : 
     682                 : } // namespace layers
     683                 : } // namespace mozilla

Generated by: LCOV version 1.7