LCOV - code coverage report
Current view: directory - objdir/ipc/ipdl - PContentChild.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 1573 4 0.3 %
Date: 2012-06-02 Functions: 140 1 0.7 %

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : 
       7                 : #include "mozilla/dom/PContentChild.h"
       8                 : #ifdef MOZ_CRASHREPORTER
       9                 : #  include "nsXULAppAPI.h"
      10                 : #endif 
      11                 : 
      12                 : #include "mozilla/dom/PAudioChild.h"
      13                 : #include "mozilla/dom/PBrowserChild.h"
      14                 : #include "mozilla/dom/PCrashReporterChild.h"
      15                 : #include "mozilla/dom/PExternalHelperAppChild.h"
      16                 : #include "mozilla/hal_sandbox/PHalChild.h"
      17                 : #include "mozilla/dom/PMemoryReportRequestChild.h"
      18                 : #include "mozilla/net/PNeckoChild.h"
      19                 : #include "mozilla/dom/sms/PSmsChild.h"
      20                 : #include "mozilla/dom/PStorageChild.h"
      21                 : #include "mozilla/ipc/PTestShellChild.h"
      22                 : 
      23                 : typedef IPC::Message Message;
      24                 : typedef mozilla::ipc::RPCChannel Channel;
      25                 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
      26                 : typedef base::ProcessHandle ProcessHandle;
      27                 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
      28                 : typedef mozilla::ipc::SharedMemory SharedMemory;
      29                 : typedef mozilla::ipc::Trigger Trigger;
      30                 : typedef mozilla::ipc::ActorHandle ActorHandle;
      31                 : typedef mozilla::dom::StorageClone StorageClone;
      32                 : typedef mozilla::dom::StorageConstructData StorageConstructData;
      33                 : typedef mozilla::dom::FontListEntry FontListEntry;
      34                 : typedef mozilla::ipc::Shmem Shmem;
      35                 : typedef IPC::URI URI;
      36                 : typedef IPC::Permission Permission;
      37                 : typedef mozilla::null_t null_t;
      38                 : typedef mozilla::dom::NativeThreadId NativeThreadId;
      39                 : using mozilla::dom::PAudioChild;
      40                 : using mozilla::dom::PBrowserChild;
      41                 : using mozilla::dom::PCrashReporterChild;
      42                 : using mozilla::dom::PExternalHelperAppChild;
      43                 : using mozilla::hal_sandbox::PHalChild;
      44                 : using mozilla::dom::PMemoryReportRequestChild;
      45                 : using mozilla::net::PNeckoChild;
      46                 : using mozilla::dom::sms::PSmsChild;
      47                 : using mozilla::dom::PStorageChild;
      48                 : using mozilla::ipc::PTestShellChild;
      49                 : 
      50                 : namespace mozilla {
      51                 : namespace dom {
      52                 : 
      53                 : 
      54                 : bool
      55               0 : PContentChild::RecvPBrowserConstructor(
      56                 :         PBrowserChild* actor,
      57                 :         const PRUint32& chromeFlags)
      58                 : {
      59               0 :     return true;
      60                 : }
      61                 : 
      62                 : bool
      63               0 : PContentChild::RecvPMemoryReportRequestConstructor(PMemoryReportRequestChild* actor)
      64                 : {
      65               0 :     return true;
      66                 : }
      67                 : 
      68                 : bool
      69               0 : PContentChild::RecvPTestShellConstructor(PTestShellChild* actor)
      70                 : {
      71               0 :     return true;
      72                 : }
      73                 : 
      74                 : void
      75               0 : PContentChild::ActorDestroy(ActorDestroyReason why)
      76                 : {
      77               0 : }
      78                 : 
      79                 : void
      80               0 : PContentChild::ProcessingError(Result code)
      81                 : {
      82               0 : }
      83                 : 
      84                 : bool
      85               0 : PContentChild::ShouldContinueFromReplyTimeout()
      86                 : {
      87               0 :     return true;
      88                 : }
      89                 : 
      90                 : void
      91               0 : PContentChild::EnteredCxxStack()
      92                 : {
      93               0 : }
      94                 : 
      95                 : void
      96               0 : PContentChild::ExitedCxxStack()
      97                 : {
      98               0 : }
      99                 : 
     100                 : void
     101               0 : PContentChild::EnteredCall()
     102                 : {
     103               0 : }
     104                 : 
     105                 : void
     106               0 : PContentChild::ExitedCall()
     107                 : {
     108               0 : }
     109                 : 
     110               1 : PContentChild::PContentChild() :
     111                 :     mChannel(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
     112                 :     mLastRouteId(0),
     113                 :     mLastShmemId(0),
     114               1 :     mState(PContent::__Start)
     115                 : {
     116               1 :     MOZ_COUNT_CTOR(PContentChild);
     117               1 : }
     118                 : 
     119               0 : PContentChild::~PContentChild()
     120                 : {
     121               0 :     MOZ_COUNT_DTOR(PContentChild);
     122               0 : }
     123                 : 
     124                 : bool
     125               0 : PContentChild::Open(
     126                 :         Channel::Transport* aTransport,
     127                 :         ProcessHandle aOtherProcess,
     128                 :         MessageLoop* aThread,
     129                 :         AsyncChannel::Side aSide)
     130                 : {
     131               0 :     mOtherProcess = aOtherProcess;
     132               0 :     return (mChannel).Open(aTransport, aThread, aSide);
     133                 : }
     134                 : 
     135                 : bool
     136               0 : PContentChild::Open(
     137                 :         AsyncChannel* aChannel,
     138                 :         MessageLoop* aMessageLoop,
     139                 :         AsyncChannel::Side aSide)
     140                 : {
     141               0 :     mOtherProcess = 0;
     142               0 :     return (mChannel).Open(aChannel, aMessageLoop, aSide);
     143                 : }
     144                 : 
     145                 : void
     146               0 : PContentChild::Close()
     147                 : {
     148               0 :     (mChannel).Close();
     149               0 : }
     150                 : 
     151                 : void
     152               0 : PContentChild::SetReplyTimeoutMs(int32 aTimeoutMs)
     153                 : {
     154               0 :     (mChannel).SetReplyTimeoutMs(aTimeoutMs);
     155               0 : }
     156                 : 
     157                 : void
     158               0 : PContentChild::ManagedPAudioChild(InfallibleTArray<PAudioChild*>& aArr) const
     159                 : {
     160               0 :     aArr = mManagedPAudioChild;
     161               0 : }
     162                 : 
     163                 : const InfallibleTArray<PAudioChild*>&
     164               0 : PContentChild::ManagedPAudioChild() const
     165                 : {
     166               0 :     return mManagedPAudioChild;
     167                 : }
     168                 : 
     169                 : void
     170               0 : PContentChild::ManagedPBrowserChild(InfallibleTArray<PBrowserChild*>& aArr) const
     171                 : {
     172               0 :     aArr = mManagedPBrowserChild;
     173               0 : }
     174                 : 
     175                 : const InfallibleTArray<PBrowserChild*>&
     176               0 : PContentChild::ManagedPBrowserChild() const
     177                 : {
     178               0 :     return mManagedPBrowserChild;
     179                 : }
     180                 : 
     181                 : void
     182               0 : PContentChild::ManagedPCrashReporterChild(InfallibleTArray<PCrashReporterChild*>& aArr) const
     183                 : {
     184               0 :     aArr = mManagedPCrashReporterChild;
     185               0 : }
     186                 : 
     187                 : const InfallibleTArray<PCrashReporterChild*>&
     188               0 : PContentChild::ManagedPCrashReporterChild() const
     189                 : {
     190               0 :     return mManagedPCrashReporterChild;
     191                 : }
     192                 : 
     193                 : void
     194               0 : PContentChild::ManagedPExternalHelperAppChild(InfallibleTArray<PExternalHelperAppChild*>& aArr) const
     195                 : {
     196               0 :     aArr = mManagedPExternalHelperAppChild;
     197               0 : }
     198                 : 
     199                 : const InfallibleTArray<PExternalHelperAppChild*>&
     200               0 : PContentChild::ManagedPExternalHelperAppChild() const
     201                 : {
     202               0 :     return mManagedPExternalHelperAppChild;
     203                 : }
     204                 : 
     205                 : void
     206               0 : PContentChild::ManagedPHalChild(InfallibleTArray<PHalChild*>& aArr) const
     207                 : {
     208               0 :     aArr = mManagedPHalChild;
     209               0 : }
     210                 : 
     211                 : const InfallibleTArray<PHalChild*>&
     212               0 : PContentChild::ManagedPHalChild() const
     213                 : {
     214               0 :     return mManagedPHalChild;
     215                 : }
     216                 : 
     217                 : void
     218               0 : PContentChild::ManagedPMemoryReportRequestChild(InfallibleTArray<PMemoryReportRequestChild*>& aArr) const
     219                 : {
     220               0 :     aArr = mManagedPMemoryReportRequestChild;
     221               0 : }
     222                 : 
     223                 : const InfallibleTArray<PMemoryReportRequestChild*>&
     224               0 : PContentChild::ManagedPMemoryReportRequestChild() const
     225                 : {
     226               0 :     return mManagedPMemoryReportRequestChild;
     227                 : }
     228                 : 
     229                 : void
     230               0 : PContentChild::ManagedPNeckoChild(InfallibleTArray<PNeckoChild*>& aArr) const
     231                 : {
     232               0 :     aArr = mManagedPNeckoChild;
     233               0 : }
     234                 : 
     235                 : const InfallibleTArray<PNeckoChild*>&
     236               0 : PContentChild::ManagedPNeckoChild() const
     237                 : {
     238               0 :     return mManagedPNeckoChild;
     239                 : }
     240                 : 
     241                 : void
     242               0 : PContentChild::ManagedPSmsChild(InfallibleTArray<PSmsChild*>& aArr) const
     243                 : {
     244               0 :     aArr = mManagedPSmsChild;
     245               0 : }
     246                 : 
     247                 : const InfallibleTArray<PSmsChild*>&
     248               0 : PContentChild::ManagedPSmsChild() const
     249                 : {
     250               0 :     return mManagedPSmsChild;
     251                 : }
     252                 : 
     253                 : void
     254               0 : PContentChild::ManagedPStorageChild(InfallibleTArray<PStorageChild*>& aArr) const
     255                 : {
     256               0 :     aArr = mManagedPStorageChild;
     257               0 : }
     258                 : 
     259                 : const InfallibleTArray<PStorageChild*>&
     260               0 : PContentChild::ManagedPStorageChild() const
     261                 : {
     262               0 :     return mManagedPStorageChild;
     263                 : }
     264                 : 
     265                 : void
     266               0 : PContentChild::ManagedPTestShellChild(InfallibleTArray<PTestShellChild*>& aArr) const
     267                 : {
     268               0 :     aArr = mManagedPTestShellChild;
     269               0 : }
     270                 : 
     271                 : const InfallibleTArray<PTestShellChild*>&
     272               0 : PContentChild::ManagedPTestShellChild() const
     273                 : {
     274               0 :     return mManagedPTestShellChild;
     275                 : }
     276                 : 
     277                 : PContent::State
     278               0 : PContentChild::state()
     279                 : {
     280               0 :     return mState;
     281                 : }
     282                 : 
     283                 : PAudioChild*
     284               0 : PContentChild::SendPAudioConstructor(
     285                 :         const PRInt32& aNumChannels,
     286                 :         const PRInt32& aRate,
     287                 :         const PRInt32& aFormat)
     288                 : {
     289               0 :     return SendPAudioConstructor(AllocPAudio(aNumChannels, aRate, aFormat), aNumChannels, aRate, aFormat);
     290                 : }
     291                 : 
     292                 : PAudioChild*
     293               0 : PContentChild::SendPAudioConstructor(
     294                 :         PAudioChild* actor,
     295                 :         const PRInt32& aNumChannels,
     296                 :         const PRInt32& aRate,
     297                 :         const PRInt32& aFormat)
     298                 : {
     299               0 :     if ((!(actor))) {
     300               0 :         return 0;
     301                 :     }
     302               0 :     (actor)->mId = Register(actor);
     303               0 :     (actor)->mManager = this;
     304               0 :     (actor)->mChannel = (&(mChannel));
     305               0 :     (mManagedPAudioChild).InsertElementSorted(actor);
     306               0 :     (actor)->mState = mozilla::dom::PAudio::__Start;
     307                 : 
     308               0 :     PContent::Msg_PAudioConstructor* __msg = new PContent::Msg_PAudioConstructor();
     309                 : 
     310               0 :     Write(actor, __msg, false);
     311               0 :     Write(aNumChannels, __msg);
     312               0 :     Write(aRate, __msg);
     313               0 :     Write(aFormat, __msg);
     314                 : 
     315               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     316                 : 
     317                 : 
     318               0 :     if (mozilla::ipc::LoggingEnabled()) {
     319               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     320                 :     }
     321               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PAudioConstructor__ID), (&(mState)))))) {
     322               0 :         NS_WARNING("bad state transition!");
     323                 :     }
     324                 : 
     325               0 :     bool __sendok = (mChannel).Send(__msg);
     326               0 :     if ((!(__sendok))) {
     327               0 :         (actor)->DestroySubtree(FailedConstructor);
     328               0 :         (actor)->DeallocSubtree();
     329               0 :         ((actor)->mManager)->RemoveManagee(PAudioMsgStart, actor);
     330               0 :         return 0;
     331                 :     }
     332               0 :     return actor;
     333                 : }
     334                 : 
     335                 : PCrashReporterChild*
     336               0 : PContentChild::SendPCrashReporterConstructor(
     337                 :         const NativeThreadId& tid,
     338                 :         const PRUint32& processType)
     339                 : {
     340               0 :     return SendPCrashReporterConstructor(AllocPCrashReporter(tid, processType), tid, processType);
     341                 : }
     342                 : 
     343                 : PCrashReporterChild*
     344               0 : PContentChild::SendPCrashReporterConstructor(
     345                 :         PCrashReporterChild* actor,
     346                 :         const NativeThreadId& tid,
     347                 :         const PRUint32& processType)
     348                 : {
     349               0 :     if ((!(actor))) {
     350               0 :         return 0;
     351                 :     }
     352               0 :     (actor)->mId = Register(actor);
     353               0 :     (actor)->mManager = this;
     354               0 :     (actor)->mChannel = (&(mChannel));
     355               0 :     (mManagedPCrashReporterChild).InsertElementSorted(actor);
     356               0 :     (actor)->mState = mozilla::dom::PCrashReporter::__Start;
     357                 : 
     358               0 :     PContent::Msg_PCrashReporterConstructor* __msg = new PContent::Msg_PCrashReporterConstructor();
     359                 : 
     360               0 :     Write(actor, __msg, false);
     361               0 :     Write(tid, __msg);
     362               0 :     Write(processType, __msg);
     363                 : 
     364               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     365               0 :     (__msg)->set_sync();
     366                 : 
     367                 : 
     368               0 :     Message __reply;
     369                 : 
     370               0 :     if (mozilla::ipc::LoggingEnabled()) {
     371               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     372                 :     }
     373               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PCrashReporterConstructor__ID), (&(mState)))))) {
     374               0 :         NS_WARNING("bad state transition!");
     375                 :     }
     376                 : 
     377               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     378               0 :     if ((!(__sendok))) {
     379               0 :         (actor)->DestroySubtree(FailedConstructor);
     380               0 :         (actor)->DeallocSubtree();
     381               0 :         ((actor)->mManager)->RemoveManagee(PCrashReporterMsgStart, actor);
     382               0 :         return 0;
     383                 :     }
     384                 : 
     385               0 :     if (mozilla::ipc::LoggingEnabled()) {
     386               0 :         (static_cast<const PContent::Reply_PCrashReporterConstructor*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
     387                 :     }
     388               0 :     return actor;
     389                 : }
     390                 : 
     391                 : PHalChild*
     392               0 : PContentChild::SendPHalConstructor()
     393                 : {
     394               0 :     return SendPHalConstructor(AllocPHal());
     395                 : }
     396                 : 
     397                 : PHalChild*
     398               0 : PContentChild::SendPHalConstructor(PHalChild* actor)
     399                 : {
     400               0 :     if ((!(actor))) {
     401               0 :         return 0;
     402                 :     }
     403               0 :     (actor)->mId = Register(actor);
     404               0 :     (actor)->mManager = this;
     405               0 :     (actor)->mChannel = (&(mChannel));
     406               0 :     (mManagedPHalChild).InsertElementSorted(actor);
     407               0 :     (actor)->mState = mozilla::hal_sandbox::PHal::__Start;
     408                 : 
     409               0 :     PContent::Msg_PHalConstructor* __msg = new PContent::Msg_PHalConstructor();
     410                 : 
     411               0 :     Write(actor, __msg, false);
     412                 : 
     413               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     414                 : 
     415                 : 
     416               0 :     if (mozilla::ipc::LoggingEnabled()) {
     417               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     418                 :     }
     419               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PHalConstructor__ID), (&(mState)))))) {
     420               0 :         NS_WARNING("bad state transition!");
     421                 :     }
     422                 : 
     423               0 :     bool __sendok = (mChannel).Send(__msg);
     424               0 :     if ((!(__sendok))) {
     425               0 :         (actor)->DestroySubtree(FailedConstructor);
     426               0 :         (actor)->DeallocSubtree();
     427               0 :         ((actor)->mManager)->RemoveManagee(PHalMsgStart, actor);
     428               0 :         return 0;
     429                 :     }
     430               0 :     return actor;
     431                 : }
     432                 : 
     433                 : PNeckoChild*
     434               0 : PContentChild::SendPNeckoConstructor()
     435                 : {
     436               0 :     return SendPNeckoConstructor(AllocPNecko());
     437                 : }
     438                 : 
     439                 : PNeckoChild*
     440               0 : PContentChild::SendPNeckoConstructor(PNeckoChild* actor)
     441                 : {
     442               0 :     if ((!(actor))) {
     443               0 :         return 0;
     444                 :     }
     445               0 :     (actor)->mId = Register(actor);
     446               0 :     (actor)->mManager = this;
     447               0 :     (actor)->mChannel = (&(mChannel));
     448               0 :     (mManagedPNeckoChild).InsertElementSorted(actor);
     449               0 :     (actor)->mState = mozilla::net::PNecko::__Start;
     450                 : 
     451               0 :     PContent::Msg_PNeckoConstructor* __msg = new PContent::Msg_PNeckoConstructor();
     452                 : 
     453               0 :     Write(actor, __msg, false);
     454                 : 
     455               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     456                 : 
     457                 : 
     458               0 :     if (mozilla::ipc::LoggingEnabled()) {
     459               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     460                 :     }
     461               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PNeckoConstructor__ID), (&(mState)))))) {
     462               0 :         NS_WARNING("bad state transition!");
     463                 :     }
     464                 : 
     465               0 :     bool __sendok = (mChannel).Send(__msg);
     466               0 :     if ((!(__sendok))) {
     467               0 :         (actor)->DestroySubtree(FailedConstructor);
     468               0 :         (actor)->DeallocSubtree();
     469               0 :         ((actor)->mManager)->RemoveManagee(PNeckoMsgStart, actor);
     470               0 :         return 0;
     471                 :     }
     472               0 :     return actor;
     473                 : }
     474                 : 
     475                 : PSmsChild*
     476               0 : PContentChild::SendPSmsConstructor()
     477                 : {
     478               0 :     return SendPSmsConstructor(AllocPSms());
     479                 : }
     480                 : 
     481                 : PSmsChild*
     482               0 : PContentChild::SendPSmsConstructor(PSmsChild* actor)
     483                 : {
     484               0 :     if ((!(actor))) {
     485               0 :         return 0;
     486                 :     }
     487               0 :     (actor)->mId = Register(actor);
     488               0 :     (actor)->mManager = this;
     489               0 :     (actor)->mChannel = (&(mChannel));
     490               0 :     (mManagedPSmsChild).InsertElementSorted(actor);
     491               0 :     (actor)->mState = mozilla::dom::sms::PSms::__Start;
     492                 : 
     493               0 :     PContent::Msg_PSmsConstructor* __msg = new PContent::Msg_PSmsConstructor();
     494                 : 
     495               0 :     Write(actor, __msg, false);
     496                 : 
     497               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     498                 : 
     499                 : 
     500               0 :     if (mozilla::ipc::LoggingEnabled()) {
     501               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     502                 :     }
     503               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PSmsConstructor__ID), (&(mState)))))) {
     504               0 :         NS_WARNING("bad state transition!");
     505                 :     }
     506                 : 
     507               0 :     bool __sendok = (mChannel).Send(__msg);
     508               0 :     if ((!(__sendok))) {
     509               0 :         (actor)->DestroySubtree(FailedConstructor);
     510               0 :         (actor)->DeallocSubtree();
     511               0 :         ((actor)->mManager)->RemoveManagee(PSmsMsgStart, actor);
     512               0 :         return 0;
     513                 :     }
     514               0 :     return actor;
     515                 : }
     516                 : 
     517                 : PStorageChild*
     518               0 : PContentChild::SendPStorageConstructor(const StorageConstructData& data)
     519                 : {
     520               0 :     return SendPStorageConstructor(AllocPStorage(data), data);
     521                 : }
     522                 : 
     523                 : PStorageChild*
     524               0 : PContentChild::SendPStorageConstructor(
     525                 :         PStorageChild* actor,
     526                 :         const StorageConstructData& data)
     527                 : {
     528               0 :     if ((!(actor))) {
     529               0 :         return 0;
     530                 :     }
     531               0 :     (actor)->mId = Register(actor);
     532               0 :     (actor)->mManager = this;
     533               0 :     (actor)->mChannel = (&(mChannel));
     534               0 :     (mManagedPStorageChild).InsertElementSorted(actor);
     535               0 :     (actor)->mState = mozilla::dom::PStorage::__Start;
     536                 : 
     537               0 :     PContent::Msg_PStorageConstructor* __msg = new PContent::Msg_PStorageConstructor();
     538                 : 
     539               0 :     Write(actor, __msg, false);
     540               0 :     Write(data, __msg);
     541                 : 
     542               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     543                 : 
     544                 : 
     545               0 :     if (mozilla::ipc::LoggingEnabled()) {
     546               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     547                 :     }
     548               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PStorageConstructor__ID), (&(mState)))))) {
     549               0 :         NS_WARNING("bad state transition!");
     550                 :     }
     551                 : 
     552               0 :     bool __sendok = (mChannel).Send(__msg);
     553               0 :     if ((!(__sendok))) {
     554               0 :         (actor)->DestroySubtree(FailedConstructor);
     555               0 :         (actor)->DeallocSubtree();
     556               0 :         ((actor)->mManager)->RemoveManagee(PStorageMsgStart, actor);
     557               0 :         return 0;
     558                 :     }
     559               0 :     return actor;
     560                 : }
     561                 : 
     562                 : bool
     563               0 : PContentChild::SendStartVisitedQuery(const URI& uri)
     564                 : {
     565               0 :     PContent::Msg_StartVisitedQuery* __msg = new PContent::Msg_StartVisitedQuery();
     566                 : 
     567               0 :     Write(uri, __msg);
     568                 : 
     569               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     570                 : 
     571                 : 
     572                 : 
     573               0 :     if (mozilla::ipc::LoggingEnabled()) {
     574               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     575                 :     }
     576               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_StartVisitedQuery__ID), (&(mState)))))) {
     577               0 :         NS_WARNING("bad state transition!");
     578                 :     }
     579                 : 
     580               0 :     bool __sendok = (mChannel).Send(__msg);
     581               0 :     return __sendok;
     582                 : }
     583                 : 
     584                 : bool
     585               0 : PContentChild::SendVisitURI(
     586                 :         const URI& uri,
     587                 :         const URI& referrer,
     588                 :         const PRUint32& flags)
     589                 : {
     590               0 :     PContent::Msg_VisitURI* __msg = new PContent::Msg_VisitURI();
     591                 : 
     592               0 :     Write(uri, __msg);
     593               0 :     Write(referrer, __msg);
     594               0 :     Write(flags, __msg);
     595                 : 
     596               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     597                 : 
     598                 : 
     599                 : 
     600               0 :     if (mozilla::ipc::LoggingEnabled()) {
     601               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     602                 :     }
     603               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_VisitURI__ID), (&(mState)))))) {
     604               0 :         NS_WARNING("bad state transition!");
     605                 :     }
     606                 : 
     607               0 :     bool __sendok = (mChannel).Send(__msg);
     608               0 :     return __sendok;
     609                 : }
     610                 : 
     611                 : bool
     612               0 : PContentChild::SendSetURITitle(
     613                 :         const URI& uri,
     614                 :         const nsString& title)
     615                 : {
     616               0 :     PContent::Msg_SetURITitle* __msg = new PContent::Msg_SetURITitle();
     617                 : 
     618               0 :     Write(uri, __msg);
     619               0 :     Write(title, __msg);
     620                 : 
     621               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     622                 : 
     623                 : 
     624                 : 
     625               0 :     if (mozilla::ipc::LoggingEnabled()) {
     626               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     627                 :     }
     628               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_SetURITitle__ID), (&(mState)))))) {
     629               0 :         NS_WARNING("bad state transition!");
     630                 :     }
     631                 : 
     632               0 :     bool __sendok = (mChannel).Send(__msg);
     633               0 :     return __sendok;
     634                 : }
     635                 : 
     636                 : bool
     637               0 : PContentChild::SendShowFilePicker(
     638                 :         const PRInt16& mode,
     639                 :         const PRInt16& selectedType,
     640                 :         const bool& addToRecentDocs,
     641                 :         const nsString& title,
     642                 :         const nsString& defaultFile,
     643                 :         const nsString& defaultExtension,
     644                 :         const InfallibleTArray<nsString>& filters,
     645                 :         const InfallibleTArray<nsString>& filterNames,
     646                 :         InfallibleTArray<nsString>* files,
     647                 :         PRInt16* retValue,
     648                 :         nsresult* result)
     649                 : {
     650               0 :     PContent::Msg_ShowFilePicker* __msg = new PContent::Msg_ShowFilePicker();
     651                 : 
     652               0 :     Write(mode, __msg);
     653               0 :     Write(selectedType, __msg);
     654               0 :     Write(addToRecentDocs, __msg);
     655               0 :     Write(title, __msg);
     656               0 :     Write(defaultFile, __msg);
     657               0 :     Write(defaultExtension, __msg);
     658               0 :     Write(filters, __msg);
     659               0 :     Write(filterNames, __msg);
     660                 : 
     661               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     662               0 :     (__msg)->set_sync();
     663                 : 
     664                 : 
     665               0 :     Message __reply;
     666                 : 
     667               0 :     if (mozilla::ipc::LoggingEnabled()) {
     668               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     669                 :     }
     670               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ShowFilePicker__ID), (&(mState)))))) {
     671               0 :         NS_WARNING("bad state transition!");
     672                 :     }
     673                 : 
     674               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     675               0 :     if ((!(__sendok))) {
     676               0 :         return false;
     677                 :     }
     678                 : 
     679               0 :     if (mozilla::ipc::LoggingEnabled()) {
     680               0 :         (static_cast<const PContent::Reply_ShowFilePicker*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
     681                 :     }
     682                 : 
     683               0 :     void* __iter = 0;
     684               0 :     if ((!(Read(files, (&(__reply)), (&(__iter)))))) {
     685               0 :         FatalError("error deserializing (better message TODO)");
     686               0 :         return false;
     687                 :     }
     688               0 :     if ((!(Read(retValue, (&(__reply)), (&(__iter)))))) {
     689               0 :         FatalError("error deserializing (better message TODO)");
     690               0 :         return false;
     691                 :     }
     692               0 :     if ((!(Read(result, (&(__reply)), (&(__iter)))))) {
     693               0 :         FatalError("error deserializing (better message TODO)");
     694               0 :         return false;
     695                 :     }
     696               0 :     (__reply).EndRead(__iter);
     697                 : 
     698               0 :     return true;
     699                 : }
     700                 : 
     701                 : bool
     702               0 : PContentChild::SendLoadURIExternal(const URI& uri)
     703                 : {
     704               0 :     PContent::Msg_LoadURIExternal* __msg = new PContent::Msg_LoadURIExternal();
     705                 : 
     706               0 :     Write(uri, __msg);
     707                 : 
     708               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     709                 : 
     710                 : 
     711                 : 
     712               0 :     if (mozilla::ipc::LoggingEnabled()) {
     713               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     714                 :     }
     715               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_LoadURIExternal__ID), (&(mState)))))) {
     716               0 :         NS_WARNING("bad state transition!");
     717                 :     }
     718                 : 
     719               0 :     bool __sendok = (mChannel).Send(__msg);
     720               0 :     return __sendok;
     721                 : }
     722                 : 
     723                 : bool
     724               0 : PContentChild::SendReadPrefsArray(InfallibleTArray<PrefTuple>* retValue)
     725                 : {
     726               0 :     PContent::Msg_ReadPrefsArray* __msg = new PContent::Msg_ReadPrefsArray();
     727                 : 
     728                 : 
     729               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     730               0 :     (__msg)->set_sync();
     731                 : 
     732                 : 
     733               0 :     Message __reply;
     734                 : 
     735               0 :     if (mozilla::ipc::LoggingEnabled()) {
     736               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     737                 :     }
     738               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ReadPrefsArray__ID), (&(mState)))))) {
     739               0 :         NS_WARNING("bad state transition!");
     740                 :     }
     741                 : 
     742               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     743               0 :     if ((!(__sendok))) {
     744               0 :         return false;
     745                 :     }
     746                 : 
     747               0 :     if (mozilla::ipc::LoggingEnabled()) {
     748               0 :         (static_cast<const PContent::Reply_ReadPrefsArray*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
     749                 :     }
     750                 : 
     751               0 :     void* __iter = 0;
     752               0 :     if ((!(Read(retValue, (&(__reply)), (&(__iter)))))) {
     753               0 :         FatalError("error deserializing (better message TODO)");
     754               0 :         return false;
     755                 :     }
     756               0 :     (__reply).EndRead(__iter);
     757                 : 
     758               0 :     return true;
     759                 : }
     760                 : 
     761                 : bool
     762               0 : PContentChild::SendReadFontList(InfallibleTArray<FontListEntry>* retValue)
     763                 : {
     764               0 :     PContent::Msg_ReadFontList* __msg = new PContent::Msg_ReadFontList();
     765                 : 
     766                 : 
     767               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     768               0 :     (__msg)->set_sync();
     769                 : 
     770                 : 
     771               0 :     Message __reply;
     772                 : 
     773               0 :     if (mozilla::ipc::LoggingEnabled()) {
     774               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     775                 :     }
     776               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ReadFontList__ID), (&(mState)))))) {
     777               0 :         NS_WARNING("bad state transition!");
     778                 :     }
     779                 : 
     780               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     781               0 :     if ((!(__sendok))) {
     782               0 :         return false;
     783                 :     }
     784                 : 
     785               0 :     if (mozilla::ipc::LoggingEnabled()) {
     786               0 :         (static_cast<const PContent::Reply_ReadFontList*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
     787                 :     }
     788                 : 
     789               0 :     void* __iter = 0;
     790               0 :     if ((!(Read(retValue, (&(__reply)), (&(__iter)))))) {
     791               0 :         FatalError("error deserializing (better message TODO)");
     792               0 :         return false;
     793                 :     }
     794               0 :     (__reply).EndRead(__iter);
     795                 : 
     796               0 :     return true;
     797                 : }
     798                 : 
     799                 : bool
     800               0 : PContentChild::SendSyncMessage(
     801                 :         const nsString& aMessage,
     802                 :         const nsString& aJSON,
     803                 :         InfallibleTArray<nsString>* retval)
     804                 : {
     805               0 :     PContent::Msg_SyncMessage* __msg = new PContent::Msg_SyncMessage();
     806                 : 
     807               0 :     Write(aMessage, __msg);
     808               0 :     Write(aJSON, __msg);
     809                 : 
     810               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     811               0 :     (__msg)->set_sync();
     812                 : 
     813                 : 
     814               0 :     Message __reply;
     815                 : 
     816               0 :     if (mozilla::ipc::LoggingEnabled()) {
     817               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     818                 :     }
     819               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_SyncMessage__ID), (&(mState)))))) {
     820               0 :         NS_WARNING("bad state transition!");
     821                 :     }
     822                 : 
     823               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
     824               0 :     if ((!(__sendok))) {
     825               0 :         return false;
     826                 :     }
     827                 : 
     828               0 :     if (mozilla::ipc::LoggingEnabled()) {
     829               0 :         (static_cast<const PContent::Reply_SyncMessage*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
     830                 :     }
     831                 : 
     832               0 :     void* __iter = 0;
     833               0 :     if ((!(Read(retval, (&(__reply)), (&(__iter)))))) {
     834               0 :         FatalError("error deserializing (better message TODO)");
     835               0 :         return false;
     836                 :     }
     837               0 :     (__reply).EndRead(__iter);
     838                 : 
     839               0 :     return true;
     840                 : }
     841                 : 
     842                 : bool
     843               0 : PContentChild::SendShowAlertNotification(
     844                 :         const nsString& imageUrl,
     845                 :         const nsString& title,
     846                 :         const nsString& text,
     847                 :         const bool& textClickable,
     848                 :         const nsString& cookie,
     849                 :         const nsString& name)
     850                 : {
     851               0 :     PContent::Msg_ShowAlertNotification* __msg = new PContent::Msg_ShowAlertNotification();
     852                 : 
     853               0 :     Write(imageUrl, __msg);
     854               0 :     Write(title, __msg);
     855               0 :     Write(text, __msg);
     856               0 :     Write(textClickable, __msg);
     857               0 :     Write(cookie, __msg);
     858               0 :     Write(name, __msg);
     859                 : 
     860               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     861                 : 
     862                 : 
     863                 : 
     864               0 :     if (mozilla::ipc::LoggingEnabled()) {
     865               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     866                 :     }
     867               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ShowAlertNotification__ID), (&(mState)))))) {
     868               0 :         NS_WARNING("bad state transition!");
     869                 :     }
     870                 : 
     871               0 :     bool __sendok = (mChannel).Send(__msg);
     872               0 :     return __sendok;
     873                 : }
     874                 : 
     875                 : PExternalHelperAppChild*
     876               0 : PContentChild::SendPExternalHelperAppConstructor(
     877                 :         const URI& uri,
     878                 :         const nsCString& aMimeContentType,
     879                 :         const nsCString& aContentDisposition,
     880                 :         const bool& aForceSave,
     881                 :         const PRInt64& aContentLength,
     882                 :         const URI& aReferrer)
     883                 : {
     884               0 :     return SendPExternalHelperAppConstructor(AllocPExternalHelperApp(uri, aMimeContentType, aContentDisposition, aForceSave, aContentLength, aReferrer), uri, aMimeContentType, aContentDisposition, aForceSave, aContentLength, aReferrer);
     885                 : }
     886                 : 
     887                 : PExternalHelperAppChild*
     888               0 : PContentChild::SendPExternalHelperAppConstructor(
     889                 :         PExternalHelperAppChild* actor,
     890                 :         const URI& uri,
     891                 :         const nsCString& aMimeContentType,
     892                 :         const nsCString& aContentDisposition,
     893                 :         const bool& aForceSave,
     894                 :         const PRInt64& aContentLength,
     895                 :         const URI& aReferrer)
     896                 : {
     897               0 :     if ((!(actor))) {
     898               0 :         return 0;
     899                 :     }
     900               0 :     (actor)->mId = Register(actor);
     901               0 :     (actor)->mManager = this;
     902               0 :     (actor)->mChannel = (&(mChannel));
     903               0 :     (mManagedPExternalHelperAppChild).InsertElementSorted(actor);
     904               0 :     (actor)->mState = mozilla::dom::PExternalHelperApp::__Start;
     905                 : 
     906               0 :     PContent::Msg_PExternalHelperAppConstructor* __msg = new PContent::Msg_PExternalHelperAppConstructor();
     907                 : 
     908               0 :     Write(actor, __msg, false);
     909               0 :     Write(uri, __msg);
     910               0 :     Write(aMimeContentType, __msg);
     911               0 :     Write(aContentDisposition, __msg);
     912               0 :     Write(aForceSave, __msg);
     913               0 :     Write(aContentLength, __msg);
     914               0 :     Write(aReferrer, __msg);
     915                 : 
     916               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     917                 : 
     918                 : 
     919               0 :     if (mozilla::ipc::LoggingEnabled()) {
     920               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     921                 :     }
     922               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_PExternalHelperAppConstructor__ID), (&(mState)))))) {
     923               0 :         NS_WARNING("bad state transition!");
     924                 :     }
     925                 : 
     926               0 :     bool __sendok = (mChannel).Send(__msg);
     927               0 :     if ((!(__sendok))) {
     928               0 :         (actor)->DestroySubtree(FailedConstructor);
     929               0 :         (actor)->DeallocSubtree();
     930               0 :         ((actor)->mManager)->RemoveManagee(PExternalHelperAppMsgStart, actor);
     931               0 :         return 0;
     932                 :     }
     933               0 :     return actor;
     934                 : }
     935                 : 
     936                 : bool
     937               0 : PContentChild::SendAddGeolocationListener()
     938                 : {
     939               0 :     PContent::Msg_AddGeolocationListener* __msg = new PContent::Msg_AddGeolocationListener();
     940                 : 
     941                 : 
     942               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     943                 : 
     944                 : 
     945                 : 
     946               0 :     if (mozilla::ipc::LoggingEnabled()) {
     947               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     948                 :     }
     949               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_AddGeolocationListener__ID), (&(mState)))))) {
     950               0 :         NS_WARNING("bad state transition!");
     951                 :     }
     952                 : 
     953               0 :     bool __sendok = (mChannel).Send(__msg);
     954               0 :     return __sendok;
     955                 : }
     956                 : 
     957                 : bool
     958               0 : PContentChild::SendRemoveGeolocationListener()
     959                 : {
     960               0 :     PContent::Msg_RemoveGeolocationListener* __msg = new PContent::Msg_RemoveGeolocationListener();
     961                 : 
     962                 : 
     963               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     964                 : 
     965                 : 
     966                 : 
     967               0 :     if (mozilla::ipc::LoggingEnabled()) {
     968               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     969                 :     }
     970               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_RemoveGeolocationListener__ID), (&(mState)))))) {
     971               0 :         NS_WARNING("bad state transition!");
     972                 :     }
     973                 : 
     974               0 :     bool __sendok = (mChannel).Send(__msg);
     975               0 :     return __sendok;
     976                 : }
     977                 : 
     978                 : bool
     979               0 : PContentChild::SendAddDeviceMotionListener()
     980                 : {
     981               0 :     PContent::Msg_AddDeviceMotionListener* __msg = new PContent::Msg_AddDeviceMotionListener();
     982                 : 
     983                 : 
     984               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
     985                 : 
     986                 : 
     987                 : 
     988               0 :     if (mozilla::ipc::LoggingEnabled()) {
     989               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
     990                 :     }
     991               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_AddDeviceMotionListener__ID), (&(mState)))))) {
     992               0 :         NS_WARNING("bad state transition!");
     993                 :     }
     994                 : 
     995               0 :     bool __sendok = (mChannel).Send(__msg);
     996               0 :     return __sendok;
     997                 : }
     998                 : 
     999                 : bool
    1000               0 : PContentChild::SendRemoveDeviceMotionListener()
    1001                 : {
    1002               0 :     PContent::Msg_RemoveDeviceMotionListener* __msg = new PContent::Msg_RemoveDeviceMotionListener();
    1003                 : 
    1004                 : 
    1005               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1006                 : 
    1007                 : 
    1008                 : 
    1009               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1010               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1011                 :     }
    1012               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_RemoveDeviceMotionListener__ID), (&(mState)))))) {
    1013               0 :         NS_WARNING("bad state transition!");
    1014                 :     }
    1015                 : 
    1016               0 :     bool __sendok = (mChannel).Send(__msg);
    1017               0 :     return __sendok;
    1018                 : }
    1019                 : 
    1020                 : bool
    1021               0 : PContentChild::SendConsoleMessage(const nsString& message)
    1022                 : {
    1023               0 :     PContent::Msg_ConsoleMessage* __msg = new PContent::Msg_ConsoleMessage();
    1024                 : 
    1025               0 :     Write(message, __msg);
    1026                 : 
    1027               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1028                 : 
    1029                 : 
    1030                 : 
    1031               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1032               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1033                 :     }
    1034               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ConsoleMessage__ID), (&(mState)))))) {
    1035               0 :         NS_WARNING("bad state transition!");
    1036                 :     }
    1037                 : 
    1038               0 :     bool __sendok = (mChannel).Send(__msg);
    1039               0 :     return __sendok;
    1040                 : }
    1041                 : 
    1042                 : bool
    1043               0 : PContentChild::SendScriptError(
    1044                 :         const nsString& message,
    1045                 :         const nsString& sourceName,
    1046                 :         const nsString& sourceLine,
    1047                 :         const PRUint32& lineNumber,
    1048                 :         const PRUint32& colNumber,
    1049                 :         const PRUint32& flags,
    1050                 :         const nsCString& category)
    1051                 : {
    1052               0 :     PContent::Msg_ScriptError* __msg = new PContent::Msg_ScriptError();
    1053                 : 
    1054               0 :     Write(message, __msg);
    1055               0 :     Write(sourceName, __msg);
    1056               0 :     Write(sourceLine, __msg);
    1057               0 :     Write(lineNumber, __msg);
    1058               0 :     Write(colNumber, __msg);
    1059               0 :     Write(flags, __msg);
    1060               0 :     Write(category, __msg);
    1061                 : 
    1062               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1063                 : 
    1064                 : 
    1065                 : 
    1066               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1067               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1068                 :     }
    1069               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ScriptError__ID), (&(mState)))))) {
    1070               0 :         NS_WARNING("bad state transition!");
    1071                 :     }
    1072                 : 
    1073               0 :     bool __sendok = (mChannel).Send(__msg);
    1074               0 :     return __sendok;
    1075                 : }
    1076                 : 
    1077                 : bool
    1078               0 : PContentChild::SendReadPermissions(InfallibleTArray<Permission>* permissions)
    1079                 : {
    1080               0 :     PContent::Msg_ReadPermissions* __msg = new PContent::Msg_ReadPermissions();
    1081                 : 
    1082                 : 
    1083               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1084               0 :     (__msg)->set_sync();
    1085                 : 
    1086                 : 
    1087               0 :     Message __reply;
    1088                 : 
    1089               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1090               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1091                 :     }
    1092               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ReadPermissions__ID), (&(mState)))))) {
    1093               0 :         NS_WARNING("bad state transition!");
    1094                 :     }
    1095                 : 
    1096               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1097               0 :     if ((!(__sendok))) {
    1098               0 :         return false;
    1099                 :     }
    1100                 : 
    1101               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1102               0 :         (static_cast<const PContent::Reply_ReadPermissions*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1103                 :     }
    1104                 : 
    1105               0 :     void* __iter = 0;
    1106               0 :     if ((!(Read(permissions, (&(__reply)), (&(__iter)))))) {
    1107               0 :         FatalError("error deserializing (better message TODO)");
    1108               0 :         return false;
    1109                 :     }
    1110               0 :     (__reply).EndRead(__iter);
    1111                 : 
    1112               0 :     return true;
    1113                 : }
    1114                 : 
    1115                 : bool
    1116               0 : PContentChild::SendGetIndexedDBDirectory(nsString* directory)
    1117                 : {
    1118               0 :     PContent::Msg_GetIndexedDBDirectory* __msg = new PContent::Msg_GetIndexedDBDirectory();
    1119                 : 
    1120                 : 
    1121               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1122               0 :     (__msg)->set_sync();
    1123                 : 
    1124                 : 
    1125               0 :     Message __reply;
    1126                 : 
    1127               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1128               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1129                 :     }
    1130               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_GetIndexedDBDirectory__ID), (&(mState)))))) {
    1131               0 :         NS_WARNING("bad state transition!");
    1132                 :     }
    1133                 : 
    1134               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1135               0 :     if ((!(__sendok))) {
    1136               0 :         return false;
    1137                 :     }
    1138                 : 
    1139               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1140               0 :         (static_cast<const PContent::Reply_GetIndexedDBDirectory*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1141                 :     }
    1142                 : 
    1143               0 :     void* __iter = 0;
    1144               0 :     if ((!(Read(directory, (&(__reply)), (&(__iter)))))) {
    1145               0 :         FatalError("error deserializing (better message TODO)");
    1146               0 :         return false;
    1147                 :     }
    1148               0 :     (__reply).EndRead(__iter);
    1149                 : 
    1150               0 :     return true;
    1151                 : }
    1152                 : 
    1153                 : bool
    1154               0 : PContentChild::SendSetClipboardText(
    1155                 :         const nsString& text,
    1156                 :         const PRInt32& whichClipboard)
    1157                 : {
    1158               0 :     PContent::Msg_SetClipboardText* __msg = new PContent::Msg_SetClipboardText();
    1159                 : 
    1160               0 :     Write(text, __msg);
    1161               0 :     Write(whichClipboard, __msg);
    1162                 : 
    1163               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1164                 : 
    1165                 : 
    1166                 : 
    1167               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1168               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1169                 :     }
    1170               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_SetClipboardText__ID), (&(mState)))))) {
    1171               0 :         NS_WARNING("bad state transition!");
    1172                 :     }
    1173                 : 
    1174               0 :     bool __sendok = (mChannel).Send(__msg);
    1175               0 :     return __sendok;
    1176                 : }
    1177                 : 
    1178                 : bool
    1179               0 : PContentChild::SendGetClipboardText(
    1180                 :         const PRInt32& whichClipboard,
    1181                 :         nsString* text)
    1182                 : {
    1183               0 :     PContent::Msg_GetClipboardText* __msg = new PContent::Msg_GetClipboardText();
    1184                 : 
    1185               0 :     Write(whichClipboard, __msg);
    1186                 : 
    1187               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1188               0 :     (__msg)->set_sync();
    1189                 : 
    1190                 : 
    1191               0 :     Message __reply;
    1192                 : 
    1193               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1194               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1195                 :     }
    1196               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_GetClipboardText__ID), (&(mState)))))) {
    1197               0 :         NS_WARNING("bad state transition!");
    1198                 :     }
    1199                 : 
    1200               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1201               0 :     if ((!(__sendok))) {
    1202               0 :         return false;
    1203                 :     }
    1204                 : 
    1205               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1206               0 :         (static_cast<const PContent::Reply_GetClipboardText*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1207                 :     }
    1208                 : 
    1209               0 :     void* __iter = 0;
    1210               0 :     if ((!(Read(text, (&(__reply)), (&(__iter)))))) {
    1211               0 :         FatalError("error deserializing (better message TODO)");
    1212               0 :         return false;
    1213                 :     }
    1214               0 :     (__reply).EndRead(__iter);
    1215                 : 
    1216               0 :     return true;
    1217                 : }
    1218                 : 
    1219                 : bool
    1220               0 : PContentChild::SendEmptyClipboard()
    1221                 : {
    1222               0 :     PContent::Msg_EmptyClipboard* __msg = new PContent::Msg_EmptyClipboard();
    1223                 : 
    1224                 : 
    1225               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1226                 : 
    1227                 : 
    1228                 : 
    1229               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1230               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1231                 :     }
    1232               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_EmptyClipboard__ID), (&(mState)))))) {
    1233               0 :         NS_WARNING("bad state transition!");
    1234                 :     }
    1235                 : 
    1236               0 :     bool __sendok = (mChannel).Send(__msg);
    1237               0 :     return __sendok;
    1238                 : }
    1239                 : 
    1240                 : bool
    1241               0 : PContentChild::SendClipboardHasText(bool* hasText)
    1242                 : {
    1243               0 :     PContent::Msg_ClipboardHasText* __msg = new PContent::Msg_ClipboardHasText();
    1244                 : 
    1245                 : 
    1246               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1247               0 :     (__msg)->set_sync();
    1248                 : 
    1249                 : 
    1250               0 :     Message __reply;
    1251                 : 
    1252               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1253               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1254                 :     }
    1255               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_ClipboardHasText__ID), (&(mState)))))) {
    1256               0 :         NS_WARNING("bad state transition!");
    1257                 :     }
    1258                 : 
    1259               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1260               0 :     if ((!(__sendok))) {
    1261               0 :         return false;
    1262                 :     }
    1263                 : 
    1264               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1265               0 :         (static_cast<const PContent::Reply_ClipboardHasText*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1266                 :     }
    1267                 : 
    1268               0 :     void* __iter = 0;
    1269               0 :     if ((!(Read(hasText, (&(__reply)), (&(__iter)))))) {
    1270               0 :         FatalError("error deserializing (better message TODO)");
    1271               0 :         return false;
    1272                 :     }
    1273               0 :     (__reply).EndRead(__iter);
    1274                 : 
    1275               0 :     return true;
    1276                 : }
    1277                 : 
    1278                 : bool
    1279               0 : PContentChild::SendGetSystemColors(
    1280                 :         const PRUint32& colorsCount,
    1281                 :         InfallibleTArray<PRUint32>* colors)
    1282                 : {
    1283               0 :     PContent::Msg_GetSystemColors* __msg = new PContent::Msg_GetSystemColors();
    1284                 : 
    1285               0 :     Write(colorsCount, __msg);
    1286                 : 
    1287               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1288               0 :     (__msg)->set_sync();
    1289                 : 
    1290                 : 
    1291               0 :     Message __reply;
    1292                 : 
    1293               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1294               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1295                 :     }
    1296               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_GetSystemColors__ID), (&(mState)))))) {
    1297               0 :         NS_WARNING("bad state transition!");
    1298                 :     }
    1299                 : 
    1300               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1301               0 :     if ((!(__sendok))) {
    1302               0 :         return false;
    1303                 :     }
    1304                 : 
    1305               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1306               0 :         (static_cast<const PContent::Reply_GetSystemColors*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1307                 :     }
    1308                 : 
    1309               0 :     void* __iter = 0;
    1310               0 :     if ((!(Read(colors, (&(__reply)), (&(__iter)))))) {
    1311               0 :         FatalError("error deserializing (better message TODO)");
    1312               0 :         return false;
    1313                 :     }
    1314               0 :     (__reply).EndRead(__iter);
    1315                 : 
    1316               0 :     return true;
    1317                 : }
    1318                 : 
    1319                 : bool
    1320               0 : PContentChild::SendGetIconForExtension(
    1321                 :         const nsCString& aFileExt,
    1322                 :         const PRUint32& aIconSize,
    1323                 :         InfallibleTArray<PRUint8>* bits)
    1324                 : {
    1325               0 :     PContent::Msg_GetIconForExtension* __msg = new PContent::Msg_GetIconForExtension();
    1326                 : 
    1327               0 :     Write(aFileExt, __msg);
    1328               0 :     Write(aIconSize, __msg);
    1329                 : 
    1330               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1331               0 :     (__msg)->set_sync();
    1332                 : 
    1333                 : 
    1334               0 :     Message __reply;
    1335                 : 
    1336               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1337               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1338                 :     }
    1339               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_GetIconForExtension__ID), (&(mState)))))) {
    1340               0 :         NS_WARNING("bad state transition!");
    1341                 :     }
    1342                 : 
    1343               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1344               0 :     if ((!(__sendok))) {
    1345               0 :         return false;
    1346                 :     }
    1347                 : 
    1348               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1349               0 :         (static_cast<const PContent::Reply_GetIconForExtension*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1350                 :     }
    1351                 : 
    1352               0 :     void* __iter = 0;
    1353               0 :     if ((!(Read(bits, (&(__reply)), (&(__iter)))))) {
    1354               0 :         FatalError("error deserializing (better message TODO)");
    1355               0 :         return false;
    1356                 :     }
    1357               0 :     (__reply).EndRead(__iter);
    1358                 : 
    1359               0 :     return true;
    1360                 : }
    1361                 : 
    1362                 : bool
    1363               0 : PContentChild::SendGetShowPasswordSetting(bool* showPassword)
    1364                 : {
    1365               0 :     PContent::Msg_GetShowPasswordSetting* __msg = new PContent::Msg_GetShowPasswordSetting();
    1366                 : 
    1367                 : 
    1368               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1369               0 :     (__msg)->set_sync();
    1370                 : 
    1371                 : 
    1372               0 :     Message __reply;
    1373                 : 
    1374               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1375               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1376                 :     }
    1377               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_GetShowPasswordSetting__ID), (&(mState)))))) {
    1378               0 :         NS_WARNING("bad state transition!");
    1379                 :     }
    1380                 : 
    1381               0 :     bool __sendok = (mChannel).Send(__msg, (&(__reply)));
    1382               0 :     if ((!(__sendok))) {
    1383               0 :         return false;
    1384                 :     }
    1385                 : 
    1386               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1387               0 :         (static_cast<const PContent::Reply_GetShowPasswordSetting*>((&(__reply))))->Log("[PContentChild] Received reply ", stderr);
    1388                 :     }
    1389                 : 
    1390               0 :     void* __iter = 0;
    1391               0 :     if ((!(Read(showPassword, (&(__reply)), (&(__iter)))))) {
    1392               0 :         FatalError("error deserializing (better message TODO)");
    1393               0 :         return false;
    1394                 :     }
    1395               0 :     (__reply).EndRead(__iter);
    1396                 : 
    1397               0 :     return true;
    1398                 : }
    1399                 : 
    1400                 : bool
    1401               0 : PContentChild::SendAsyncMessage(
    1402                 :         const nsString& aMessage,
    1403                 :         const nsString& aJSON)
    1404                 : {
    1405               0 :     PContent::Msg_AsyncMessage* __msg = new PContent::Msg_AsyncMessage();
    1406                 : 
    1407               0 :     Write(aMessage, __msg);
    1408               0 :     Write(aJSON, __msg);
    1409                 : 
    1410               0 :     (__msg)->set_routing_id(MSG_ROUTING_CONTROL);
    1411                 : 
    1412                 : 
    1413                 : 
    1414               0 :     if (mozilla::ipc::LoggingEnabled()) {
    1415               0 :         (__msg)->Log("[PContentChild] Sending ", stderr);
    1416                 :     }
    1417               0 :     if ((!(PContent::Transition(mState, Trigger(Trigger::Recv, PContent::Msg_AsyncMessage__ID), (&(mState)))))) {
    1418               0 :         NS_WARNING("bad state transition!");
    1419                 :     }
    1420                 : 
    1421               0 :     bool __sendok = (mChannel).Send(__msg);
    1422               0 :     return __sendok;
    1423                 : }
    1424                 : 
    1425                 : int32
    1426               0 : PContentChild::Register(ChannelListener* aRouted)
    1427                 : {
    1428               0 :     int32 tmp = (--(mLastRouteId));
    1429               0 :     (mActorMap).AddWithID(aRouted, tmp);
    1430               0 :     return tmp;
    1431                 : }
    1432                 : 
    1433                 : int32
    1434               0 : PContentChild::RegisterID(
    1435                 :         ChannelListener* aRouted,
    1436                 :         int32 aId)
    1437                 : {
    1438               0 :     (mActorMap).AddWithID(aRouted, aId);
    1439               0 :     return aId;
    1440                 : }
    1441                 : 
    1442                 : ChannelListener*
    1443               0 : PContentChild::Lookup(int32 aId)
    1444                 : {
    1445               0 :     return (mActorMap).Lookup(aId);
    1446                 : }
    1447                 : 
    1448                 : void
    1449               0 : PContentChild::Unregister(int32 aId)
    1450                 : {
    1451               0 :     return (mActorMap).Remove(aId);
    1452                 : }
    1453                 : 
    1454                 : void
    1455               0 : PContentChild::RemoveManagee(
    1456                 :         int32 aProtocolId,
    1457                 :         ChannelListener* aListener)
    1458                 : {
    1459               0 :     switch (aProtocolId) {
    1460                 :     case PAudioMsgStart:
    1461                 :         {
    1462               0 :             PAudioChild* actor = static_cast<PAudioChild*>(aListener);
    1463               0 :             NS_ABORT_IF_FALSE(((mManagedPAudioChild).NoIndex) != ((mManagedPAudioChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1464                 : 
    1465               0 :             (mManagedPAudioChild).RemoveElementSorted(actor);
    1466               0 :             DeallocPAudio(actor);
    1467               0 :             return;
    1468                 :         }
    1469                 :     case PBrowserMsgStart:
    1470                 :         {
    1471               0 :             PBrowserChild* actor = static_cast<PBrowserChild*>(aListener);
    1472               0 :             NS_ABORT_IF_FALSE(((mManagedPBrowserChild).NoIndex) != ((mManagedPBrowserChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1473                 : 
    1474               0 :             (mManagedPBrowserChild).RemoveElementSorted(actor);
    1475               0 :             DeallocPBrowser(actor);
    1476               0 :             return;
    1477                 :         }
    1478                 :     case PCrashReporterMsgStart:
    1479                 :         {
    1480               0 :             PCrashReporterChild* actor = static_cast<PCrashReporterChild*>(aListener);
    1481               0 :             NS_ABORT_IF_FALSE(((mManagedPCrashReporterChild).NoIndex) != ((mManagedPCrashReporterChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1482                 : 
    1483               0 :             (mManagedPCrashReporterChild).RemoveElementSorted(actor);
    1484               0 :             DeallocPCrashReporter(actor);
    1485               0 :             return;
    1486                 :         }
    1487                 :     case PExternalHelperAppMsgStart:
    1488                 :         {
    1489               0 :             PExternalHelperAppChild* actor = static_cast<PExternalHelperAppChild*>(aListener);
    1490               0 :             NS_ABORT_IF_FALSE(((mManagedPExternalHelperAppChild).NoIndex) != ((mManagedPExternalHelperAppChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1491                 : 
    1492               0 :             (mManagedPExternalHelperAppChild).RemoveElementSorted(actor);
    1493               0 :             DeallocPExternalHelperApp(actor);
    1494               0 :             return;
    1495                 :         }
    1496                 :     case PHalMsgStart:
    1497                 :         {
    1498               0 :             PHalChild* actor = static_cast<PHalChild*>(aListener);
    1499               0 :             NS_ABORT_IF_FALSE(((mManagedPHalChild).NoIndex) != ((mManagedPHalChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1500                 : 
    1501               0 :             (mManagedPHalChild).RemoveElementSorted(actor);
    1502               0 :             DeallocPHal(actor);
    1503               0 :             return;
    1504                 :         }
    1505                 :     case PMemoryReportRequestMsgStart:
    1506                 :         {
    1507               0 :             PMemoryReportRequestChild* actor = static_cast<PMemoryReportRequestChild*>(aListener);
    1508               0 :             NS_ABORT_IF_FALSE(((mManagedPMemoryReportRequestChild).NoIndex) != ((mManagedPMemoryReportRequestChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1509                 : 
    1510               0 :             (mManagedPMemoryReportRequestChild).RemoveElementSorted(actor);
    1511               0 :             DeallocPMemoryReportRequest(actor);
    1512               0 :             return;
    1513                 :         }
    1514                 :     case PNeckoMsgStart:
    1515                 :         {
    1516               0 :             PNeckoChild* actor = static_cast<PNeckoChild*>(aListener);
    1517               0 :             NS_ABORT_IF_FALSE(((mManagedPNeckoChild).NoIndex) != ((mManagedPNeckoChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1518                 : 
    1519               0 :             (mManagedPNeckoChild).RemoveElementSorted(actor);
    1520               0 :             DeallocPNecko(actor);
    1521               0 :             return;
    1522                 :         }
    1523                 :     case PSmsMsgStart:
    1524                 :         {
    1525               0 :             PSmsChild* actor = static_cast<PSmsChild*>(aListener);
    1526               0 :             NS_ABORT_IF_FALSE(((mManagedPSmsChild).NoIndex) != ((mManagedPSmsChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1527                 : 
    1528               0 :             (mManagedPSmsChild).RemoveElementSorted(actor);
    1529               0 :             DeallocPSms(actor);
    1530               0 :             return;
    1531                 :         }
    1532                 :     case PStorageMsgStart:
    1533                 :         {
    1534               0 :             PStorageChild* actor = static_cast<PStorageChild*>(aListener);
    1535               0 :             NS_ABORT_IF_FALSE(((mManagedPStorageChild).NoIndex) != ((mManagedPStorageChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1536                 : 
    1537               0 :             (mManagedPStorageChild).RemoveElementSorted(actor);
    1538               0 :             DeallocPStorage(actor);
    1539               0 :             return;
    1540                 :         }
    1541                 :     case PTestShellMsgStart:
    1542                 :         {
    1543               0 :             PTestShellChild* actor = static_cast<PTestShellChild*>(aListener);
    1544               0 :             NS_ABORT_IF_FALSE(((mManagedPTestShellChild).NoIndex) != ((mManagedPTestShellChild).BinaryIndexOf(actor)), "actor not managed by this!");
    1545                 : 
    1546               0 :             (mManagedPTestShellChild).RemoveElementSorted(actor);
    1547               0 :             DeallocPTestShell(actor);
    1548               0 :             return;
    1549                 :         }
    1550                 :     default:
    1551                 :         {
    1552               0 :             NS_RUNTIMEABORT("unreached");
    1553               0 :             return;
    1554                 :         }
    1555                 :     }
    1556                 : }
    1557                 : 
    1558                 : Shmem::SharedMemory*
    1559               0 : PContentChild::CreateSharedMemory(
    1560                 :         size_t aSize,
    1561                 :         Shmem::SharedMemory::SharedMemoryType type,
    1562                 :         bool unsafe,
    1563                 :         Shmem::id_t* aId)
    1564                 : {
    1565               0 :     nsAutoPtr<Shmem::SharedMemory> segment(Shmem::Alloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), aSize, type, unsafe));
    1566               0 :     if ((!(segment))) {
    1567               0 :         return 0;
    1568                 :     }
    1569                 :     Shmem aShmem(
    1570                 :             Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(),
    1571                 :             (segment).get(),
    1572               0 :             (--(mLastShmemId)));
    1573               0 :     Message* descriptor = (aShmem).ShareTo(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
    1574               0 :     if ((!(descriptor))) {
    1575               0 :         return 0;
    1576                 :     }
    1577               0 :     if ((!((mChannel).Send(descriptor)))) {
    1578                 :     }
    1579               0 :     (*(aId)) = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1580               0 :     (mShmemMap).AddWithID(segment, (*(aId)));
    1581               0 :     return (segment).forget();
    1582                 : }
    1583                 : 
    1584                 : bool
    1585               0 : PContentChild::AdoptSharedMemory(
    1586                 :         Shmem::SharedMemory* segment,
    1587                 :         Shmem::id_t* aId)
    1588                 : {
    1589                 :     Shmem aShmem(
    1590                 :             Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(),
    1591                 :             segment,
    1592               0 :             (--(mLastShmemId)));
    1593               0 :     Message* descriptor = (aShmem).ShareTo(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
    1594               0 :     if ((!(descriptor))) {
    1595               0 :         return false;
    1596                 :     }
    1597               0 :     if ((!((mChannel).Send(descriptor)))) {
    1598                 :     }
    1599               0 :     (*(aId)) = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1600               0 :     (mShmemMap).AddWithID(segment, (*(aId)));
    1601               0 :     (segment)->AddRef();
    1602               0 :     return true;
    1603                 : }
    1604                 : 
    1605                 : Shmem::SharedMemory*
    1606               0 : PContentChild::LookupSharedMemory(Shmem::id_t aId)
    1607                 : {
    1608               0 :     return (mShmemMap).Lookup(aId);
    1609                 : }
    1610                 : 
    1611                 : bool
    1612               0 : PContentChild::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
    1613                 : {
    1614               0 :     return (mShmemMap).HasData(segment);
    1615                 : }
    1616                 : 
    1617                 : bool
    1618               0 : PContentChild::DestroySharedMemory(Shmem& aShmem)
    1619                 : {
    1620               0 :     Shmem::id_t aId = (aShmem).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    1621               0 :     Shmem::SharedMemory* segment = LookupSharedMemory(aId);
    1622               0 :     if ((!(segment))) {
    1623               0 :         return false;
    1624                 :     }
    1625               0 :     Message* descriptor = (aShmem).UnshareFrom(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), OtherProcess(), MSG_ROUTING_CONTROL);
    1626                 : 
    1627               0 :     (mShmemMap).Remove(aId);
    1628               0 :     Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), segment);
    1629                 : 
    1630               0 :     return (descriptor) && ((mChannel).Send(descriptor));
    1631                 : }
    1632                 : 
    1633                 : ProcessHandle
    1634               0 : PContentChild::OtherProcess() const
    1635                 : {
    1636               0 :     return mOtherProcess;
    1637                 : }
    1638                 : 
    1639                 : AsyncChannel*
    1640               0 : PContentChild::GetIPCChannel()
    1641                 : {
    1642               0 :     return (&(mChannel));
    1643                 : }
    1644                 : 
    1645                 : PContentChild::Result
    1646               0 : PContentChild::OnMessageReceived(const Message& __msg)
    1647                 : {
    1648               0 :     int32 __route = (__msg).routing_id();
    1649               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
    1650               0 :         ChannelListener* __routed = Lookup(__route);
    1651               0 :         if ((!(__routed))) {
    1652               0 :             return MsgRouteError;
    1653                 :         }
    1654               0 :         return (__routed)->OnMessageReceived(__msg);
    1655                 :     }
    1656                 : 
    1657               0 :     switch ((__msg).type()) {
    1658                 :     case PContent::Msg_PBrowserConstructor__ID:
    1659                 :         {
    1660               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_PBrowserConstructor");
    1661               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1662               0 :                 (static_cast<const PContent::Msg_PBrowserConstructor*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1663                 :             }
    1664                 : 
    1665               0 :             void* __iter = 0;
    1666                 :             ActorHandle __handle;
    1667                 :             PBrowserChild* actor;
    1668                 :             PRUint32 chromeFlags;
    1669                 : 
    1670               0 :             if ((!(Read((&(__handle)), (&(__msg)), (&(__iter)))))) {
    1671               0 :                 FatalError("error deserializing (better message TODO)");
    1672               0 :                 return MsgValueError;
    1673                 :             }
    1674               0 :             if ((!(Read((&(chromeFlags)), (&(__msg)), (&(__iter)))))) {
    1675               0 :                 FatalError("error deserializing (better message TODO)");
    1676               0 :                 return MsgValueError;
    1677                 :             }
    1678               0 :             (__msg).EndRead(__iter);
    1679               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_PBrowserConstructor__ID), (&(mState)))))) {
    1680               0 :                 NS_WARNING("bad state transition!");
    1681                 :             }
    1682               0 :             actor = AllocPBrowser(chromeFlags);
    1683               0 :             if ((!(actor))) {
    1684               0 :                 return MsgValueError;
    1685                 :             }
    1686               0 :             (actor)->mId = RegisterID(actor, (__handle).mId);
    1687               0 :             (actor)->mManager = this;
    1688               0 :             (actor)->mChannel = (&(mChannel));
    1689               0 :             (mManagedPBrowserChild).InsertElementSorted(actor);
    1690               0 :             (actor)->mState = mozilla::dom::PBrowser::__Start;
    1691                 : 
    1692               0 :             if ((!(RecvPBrowserConstructor(actor, chromeFlags)))) {
    1693               0 :                 return MsgProcessingError;
    1694                 :             }
    1695                 : 
    1696               0 :             return MsgProcessed;
    1697                 :         }
    1698                 :     case PContent::Msg_PMemoryReportRequestConstructor__ID:
    1699                 :         {
    1700               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_PMemoryReportRequestConstructor");
    1701               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1702               0 :                 (static_cast<const PContent::Msg_PMemoryReportRequestConstructor*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1703                 :             }
    1704                 : 
    1705               0 :             void* __iter = 0;
    1706                 :             ActorHandle __handle;
    1707                 :             PMemoryReportRequestChild* actor;
    1708                 : 
    1709               0 :             if ((!(Read((&(__handle)), (&(__msg)), (&(__iter)))))) {
    1710               0 :                 FatalError("error deserializing (better message TODO)");
    1711               0 :                 return MsgValueError;
    1712                 :             }
    1713               0 :             (__msg).EndRead(__iter);
    1714               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_PMemoryReportRequestConstructor__ID), (&(mState)))))) {
    1715               0 :                 NS_WARNING("bad state transition!");
    1716                 :             }
    1717               0 :             actor = AllocPMemoryReportRequest();
    1718               0 :             if ((!(actor))) {
    1719               0 :                 return MsgValueError;
    1720                 :             }
    1721               0 :             (actor)->mId = RegisterID(actor, (__handle).mId);
    1722               0 :             (actor)->mManager = this;
    1723               0 :             (actor)->mChannel = (&(mChannel));
    1724               0 :             (mManagedPMemoryReportRequestChild).InsertElementSorted(actor);
    1725               0 :             (actor)->mState = mozilla::dom::PMemoryReportRequest::__Start;
    1726                 : 
    1727               0 :             if ((!(RecvPMemoryReportRequestConstructor(actor)))) {
    1728               0 :                 return MsgProcessingError;
    1729                 :             }
    1730                 : 
    1731               0 :             return MsgProcessed;
    1732                 :         }
    1733                 :     case PContent::Msg_PTestShellConstructor__ID:
    1734                 :         {
    1735               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_PTestShellConstructor");
    1736               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1737               0 :                 (static_cast<const PContent::Msg_PTestShellConstructor*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1738                 :             }
    1739                 : 
    1740               0 :             void* __iter = 0;
    1741                 :             ActorHandle __handle;
    1742                 :             PTestShellChild* actor;
    1743                 : 
    1744               0 :             if ((!(Read((&(__handle)), (&(__msg)), (&(__iter)))))) {
    1745               0 :                 FatalError("error deserializing (better message TODO)");
    1746               0 :                 return MsgValueError;
    1747                 :             }
    1748               0 :             (__msg).EndRead(__iter);
    1749               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_PTestShellConstructor__ID), (&(mState)))))) {
    1750               0 :                 NS_WARNING("bad state transition!");
    1751                 :             }
    1752               0 :             actor = AllocPTestShell();
    1753               0 :             if ((!(actor))) {
    1754               0 :                 return MsgValueError;
    1755                 :             }
    1756               0 :             (actor)->mId = RegisterID(actor, (__handle).mId);
    1757               0 :             (actor)->mManager = this;
    1758               0 :             (actor)->mChannel = (&(mChannel));
    1759               0 :             (mManagedPTestShellChild).InsertElementSorted(actor);
    1760               0 :             (actor)->mState = mozilla::ipc::PTestShell::__Start;
    1761                 : 
    1762               0 :             if ((!(RecvPTestShellConstructor(actor)))) {
    1763               0 :                 return MsgProcessingError;
    1764                 :             }
    1765                 : 
    1766               0 :             return MsgProcessed;
    1767                 :         }
    1768                 :     case PContent::Msg_RegisterChrome__ID:
    1769                 :         {
    1770               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_RegisterChrome");
    1771               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1772               0 :                 (static_cast<const PContent::Msg_RegisterChrome*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1773                 :             }
    1774                 : 
    1775               0 :             void* __iter = 0;
    1776               0 :             InfallibleTArray<ChromePackage> packages;
    1777               0 :             InfallibleTArray<ResourceMapping> resources;
    1778               0 :             InfallibleTArray<OverrideMapping> overrides;
    1779               0 :             nsCString locale;
    1780                 : 
    1781               0 :             if ((!(Read((&(packages)), (&(__msg)), (&(__iter)))))) {
    1782               0 :                 FatalError("error deserializing (better message TODO)");
    1783               0 :                 return MsgValueError;
    1784                 :             }
    1785               0 :             if ((!(Read((&(resources)), (&(__msg)), (&(__iter)))))) {
    1786               0 :                 FatalError("error deserializing (better message TODO)");
    1787               0 :                 return MsgValueError;
    1788                 :             }
    1789               0 :             if ((!(Read((&(overrides)), (&(__msg)), (&(__iter)))))) {
    1790               0 :                 FatalError("error deserializing (better message TODO)");
    1791               0 :                 return MsgValueError;
    1792                 :             }
    1793               0 :             if ((!(Read((&(locale)), (&(__msg)), (&(__iter)))))) {
    1794               0 :                 FatalError("error deserializing (better message TODO)");
    1795               0 :                 return MsgValueError;
    1796                 :             }
    1797               0 :             (__msg).EndRead(__iter);
    1798               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_RegisterChrome__ID), (&(mState)))))) {
    1799               0 :                 NS_WARNING("bad state transition!");
    1800                 :             }
    1801               0 :             if ((!(RecvRegisterChrome(packages, resources, overrides, locale)))) {
    1802               0 :                 return MsgProcessingError;
    1803                 :             }
    1804                 : 
    1805               0 :             return MsgProcessed;
    1806                 :         }
    1807                 :     case PContent::Msg_SetOffline__ID:
    1808                 :         {
    1809               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_SetOffline");
    1810               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1811               0 :                 (static_cast<const PContent::Msg_SetOffline*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1812                 :             }
    1813                 : 
    1814               0 :             void* __iter = 0;
    1815                 :             bool offline;
    1816                 : 
    1817               0 :             if ((!(Read((&(offline)), (&(__msg)), (&(__iter)))))) {
    1818               0 :                 FatalError("error deserializing (better message TODO)");
    1819               0 :                 return MsgValueError;
    1820                 :             }
    1821               0 :             (__msg).EndRead(__iter);
    1822               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_SetOffline__ID), (&(mState)))))) {
    1823               0 :                 NS_WARNING("bad state transition!");
    1824                 :             }
    1825               0 :             if ((!(RecvSetOffline(offline)))) {
    1826               0 :                 return MsgProcessingError;
    1827                 :             }
    1828                 : 
    1829               0 :             return MsgProcessed;
    1830                 :         }
    1831                 :     case PContent::Msg_NotifyVisited__ID:
    1832                 :         {
    1833               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_NotifyVisited");
    1834               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1835               0 :                 (static_cast<const PContent::Msg_NotifyVisited*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1836                 :             }
    1837                 : 
    1838               0 :             void* __iter = 0;
    1839               0 :             URI uri;
    1840                 : 
    1841               0 :             if ((!(Read((&(uri)), (&(__msg)), (&(__iter)))))) {
    1842               0 :                 FatalError("error deserializing (better message TODO)");
    1843               0 :                 return MsgValueError;
    1844                 :             }
    1845               0 :             (__msg).EndRead(__iter);
    1846               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_NotifyVisited__ID), (&(mState)))))) {
    1847               0 :                 NS_WARNING("bad state transition!");
    1848                 :             }
    1849               0 :             if ((!(RecvNotifyVisited(uri)))) {
    1850               0 :                 return MsgProcessingError;
    1851                 :             }
    1852                 : 
    1853               0 :             return MsgProcessed;
    1854                 :         }
    1855                 :     case PContent::Msg_PreferenceUpdate__ID:
    1856                 :         {
    1857               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_PreferenceUpdate");
    1858               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1859               0 :                 (static_cast<const PContent::Msg_PreferenceUpdate*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1860                 :             }
    1861                 : 
    1862               0 :             void* __iter = 0;
    1863               0 :             PrefTuple pref;
    1864                 : 
    1865               0 :             if ((!(Read((&(pref)), (&(__msg)), (&(__iter)))))) {
    1866               0 :                 FatalError("error deserializing (better message TODO)");
    1867               0 :                 return MsgValueError;
    1868                 :             }
    1869               0 :             (__msg).EndRead(__iter);
    1870               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_PreferenceUpdate__ID), (&(mState)))))) {
    1871               0 :                 NS_WARNING("bad state transition!");
    1872                 :             }
    1873               0 :             if ((!(RecvPreferenceUpdate(pref)))) {
    1874               0 :                 return MsgProcessingError;
    1875                 :             }
    1876                 : 
    1877               0 :             return MsgProcessed;
    1878                 :         }
    1879                 :     case PContent::Msg_ClearUserPreference__ID:
    1880                 :         {
    1881               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_ClearUserPreference");
    1882               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1883               0 :                 (static_cast<const PContent::Msg_ClearUserPreference*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1884                 :             }
    1885                 : 
    1886               0 :             void* __iter = 0;
    1887               0 :             nsCString prefName;
    1888                 : 
    1889               0 :             if ((!(Read((&(prefName)), (&(__msg)), (&(__iter)))))) {
    1890               0 :                 FatalError("error deserializing (better message TODO)");
    1891               0 :                 return MsgValueError;
    1892                 :             }
    1893               0 :             (__msg).EndRead(__iter);
    1894               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_ClearUserPreference__ID), (&(mState)))))) {
    1895               0 :                 NS_WARNING("bad state transition!");
    1896                 :             }
    1897               0 :             if ((!(RecvClearUserPreference(prefName)))) {
    1898               0 :                 return MsgProcessingError;
    1899                 :             }
    1900                 : 
    1901               0 :             return MsgProcessed;
    1902                 :         }
    1903                 :     case PContent::Msg_NotifyAlertsObserver__ID:
    1904                 :         {
    1905               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_NotifyAlertsObserver");
    1906               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1907               0 :                 (static_cast<const PContent::Msg_NotifyAlertsObserver*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1908                 :             }
    1909                 : 
    1910               0 :             void* __iter = 0;
    1911               0 :             nsCString topic;
    1912               0 :             nsString data;
    1913                 : 
    1914               0 :             if ((!(Read((&(topic)), (&(__msg)), (&(__iter)))))) {
    1915               0 :                 FatalError("error deserializing (better message TODO)");
    1916               0 :                 return MsgValueError;
    1917                 :             }
    1918               0 :             if ((!(Read((&(data)), (&(__msg)), (&(__iter)))))) {
    1919               0 :                 FatalError("error deserializing (better message TODO)");
    1920               0 :                 return MsgValueError;
    1921                 :             }
    1922               0 :             (__msg).EndRead(__iter);
    1923               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_NotifyAlertsObserver__ID), (&(mState)))))) {
    1924               0 :                 NS_WARNING("bad state transition!");
    1925                 :             }
    1926               0 :             if ((!(RecvNotifyAlertsObserver(topic, data)))) {
    1927               0 :                 return MsgProcessingError;
    1928                 :             }
    1929                 : 
    1930               0 :             return MsgProcessed;
    1931                 :         }
    1932                 :     case PContent::Msg_GeolocationUpdate__ID:
    1933                 :         {
    1934               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_GeolocationUpdate");
    1935               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1936               0 :                 (static_cast<const PContent::Msg_GeolocationUpdate*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1937                 :             }
    1938                 : 
    1939               0 :             void* __iter = 0;
    1940                 :             GeoPosition somewhere;
    1941                 : 
    1942               0 :             if ((!(Read((&(somewhere)), (&(__msg)), (&(__iter)))))) {
    1943               0 :                 FatalError("error deserializing (better message TODO)");
    1944               0 :                 return MsgValueError;
    1945                 :             }
    1946               0 :             (__msg).EndRead(__iter);
    1947               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_GeolocationUpdate__ID), (&(mState)))))) {
    1948               0 :                 NS_WARNING("bad state transition!");
    1949                 :             }
    1950               0 :             if ((!(RecvGeolocationUpdate(somewhere)))) {
    1951               0 :                 return MsgProcessingError;
    1952                 :             }
    1953                 : 
    1954               0 :             return MsgProcessed;
    1955                 :         }
    1956                 :     case PContent::Msg_AddPermission__ID:
    1957                 :         {
    1958               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_AddPermission");
    1959               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1960               0 :                 (static_cast<const PContent::Msg_AddPermission*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1961                 :             }
    1962                 : 
    1963               0 :             void* __iter = 0;
    1964               0 :             Permission permission;
    1965                 : 
    1966               0 :             if ((!(Read((&(permission)), (&(__msg)), (&(__iter)))))) {
    1967               0 :                 FatalError("error deserializing (better message TODO)");
    1968               0 :                 return MsgValueError;
    1969                 :             }
    1970               0 :             (__msg).EndRead(__iter);
    1971               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_AddPermission__ID), (&(mState)))))) {
    1972               0 :                 NS_WARNING("bad state transition!");
    1973                 :             }
    1974               0 :             if ((!(RecvAddPermission(permission)))) {
    1975               0 :                 return MsgProcessingError;
    1976                 :             }
    1977                 : 
    1978               0 :             return MsgProcessed;
    1979                 :         }
    1980                 :     case PContent::Msg_DeviceMotionChanged__ID:
    1981                 :         {
    1982               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_DeviceMotionChanged");
    1983               0 :             if (mozilla::ipc::LoggingEnabled()) {
    1984               0 :                 (static_cast<const PContent::Msg_DeviceMotionChanged*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    1985                 :             }
    1986                 : 
    1987               0 :             void* __iter = 0;
    1988                 :             long type;
    1989                 :             double x;
    1990                 :             double y;
    1991                 :             double z;
    1992                 : 
    1993               0 :             if ((!(Read((&(type)), (&(__msg)), (&(__iter)))))) {
    1994               0 :                 FatalError("error deserializing (better message TODO)");
    1995               0 :                 return MsgValueError;
    1996                 :             }
    1997               0 :             if ((!(Read((&(x)), (&(__msg)), (&(__iter)))))) {
    1998               0 :                 FatalError("error deserializing (better message TODO)");
    1999               0 :                 return MsgValueError;
    2000                 :             }
    2001               0 :             if ((!(Read((&(y)), (&(__msg)), (&(__iter)))))) {
    2002               0 :                 FatalError("error deserializing (better message TODO)");
    2003               0 :                 return MsgValueError;
    2004                 :             }
    2005               0 :             if ((!(Read((&(z)), (&(__msg)), (&(__iter)))))) {
    2006               0 :                 FatalError("error deserializing (better message TODO)");
    2007               0 :                 return MsgValueError;
    2008                 :             }
    2009               0 :             (__msg).EndRead(__iter);
    2010               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_DeviceMotionChanged__ID), (&(mState)))))) {
    2011               0 :                 NS_WARNING("bad state transition!");
    2012                 :             }
    2013               0 :             if ((!(RecvDeviceMotionChanged(type, x, y, z)))) {
    2014               0 :                 return MsgProcessingError;
    2015                 :             }
    2016                 : 
    2017               0 :             return MsgProcessed;
    2018                 :         }
    2019                 :     case PContent::Msg_ScreenSizeChanged__ID:
    2020                 :         {
    2021               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_ScreenSizeChanged");
    2022               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2023               0 :                 (static_cast<const PContent::Msg_ScreenSizeChanged*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2024                 :             }
    2025                 : 
    2026               0 :             void* __iter = 0;
    2027               0 :             gfxIntSize size;
    2028                 : 
    2029               0 :             if ((!(Read((&(size)), (&(__msg)), (&(__iter)))))) {
    2030               0 :                 FatalError("error deserializing (better message TODO)");
    2031               0 :                 return MsgValueError;
    2032                 :             }
    2033               0 :             (__msg).EndRead(__iter);
    2034               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_ScreenSizeChanged__ID), (&(mState)))))) {
    2035               0 :                 NS_WARNING("bad state transition!");
    2036                 :             }
    2037               0 :             if ((!(RecvScreenSizeChanged(size)))) {
    2038               0 :                 return MsgProcessingError;
    2039                 :             }
    2040                 : 
    2041               0 :             return MsgProcessed;
    2042                 :         }
    2043                 :     case PContent::Msg_FlushMemory__ID:
    2044                 :         {
    2045               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_FlushMemory");
    2046               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2047               0 :                 (static_cast<const PContent::Msg_FlushMemory*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2048                 :             }
    2049                 : 
    2050               0 :             void* __iter = 0;
    2051               0 :             nsString reason;
    2052                 : 
    2053               0 :             if ((!(Read((&(reason)), (&(__msg)), (&(__iter)))))) {
    2054               0 :                 FatalError("error deserializing (better message TODO)");
    2055               0 :                 return MsgValueError;
    2056                 :             }
    2057               0 :             (__msg).EndRead(__iter);
    2058               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_FlushMemory__ID), (&(mState)))))) {
    2059               0 :                 NS_WARNING("bad state transition!");
    2060                 :             }
    2061               0 :             if ((!(RecvFlushMemory(reason)))) {
    2062               0 :                 return MsgProcessingError;
    2063                 :             }
    2064                 : 
    2065               0 :             return MsgProcessed;
    2066                 :         }
    2067                 :     case PContent::Msg_GarbageCollect__ID:
    2068                 :         {
    2069               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_GarbageCollect");
    2070               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2071               0 :                 (static_cast<const PContent::Msg_GarbageCollect*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2072                 :             }
    2073                 : 
    2074               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_GarbageCollect__ID), (&(mState)))))) {
    2075               0 :                 NS_WARNING("bad state transition!");
    2076                 :             }
    2077               0 :             if ((!(RecvGarbageCollect()))) {
    2078               0 :                 return MsgProcessingError;
    2079                 :             }
    2080                 : 
    2081               0 :             return MsgProcessed;
    2082                 :         }
    2083                 :     case PContent::Msg_CycleCollect__ID:
    2084                 :         {
    2085               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_CycleCollect");
    2086               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2087               0 :                 (static_cast<const PContent::Msg_CycleCollect*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2088                 :             }
    2089                 : 
    2090               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_CycleCollect__ID), (&(mState)))))) {
    2091               0 :                 NS_WARNING("bad state transition!");
    2092                 :             }
    2093               0 :             if ((!(RecvCycleCollect()))) {
    2094               0 :                 return MsgProcessingError;
    2095                 :             }
    2096                 : 
    2097               0 :             return MsgProcessed;
    2098                 :         }
    2099                 :     case PContent::Msg_ActivateA11y__ID:
    2100                 :         {
    2101               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_ActivateA11y");
    2102               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2103               0 :                 (static_cast<const PContent::Msg_ActivateA11y*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2104                 :             }
    2105                 : 
    2106               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_ActivateA11y__ID), (&(mState)))))) {
    2107               0 :                 NS_WARNING("bad state transition!");
    2108                 :             }
    2109               0 :             if ((!(RecvActivateA11y()))) {
    2110               0 :                 return MsgProcessingError;
    2111                 :             }
    2112                 : 
    2113               0 :             return MsgProcessed;
    2114                 :         }
    2115                 :     case PContent::Msg_AppInfo__ID:
    2116                 :         {
    2117               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_AppInfo");
    2118               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2119               0 :                 (static_cast<const PContent::Msg_AppInfo*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2120                 :             }
    2121                 : 
    2122               0 :             void* __iter = 0;
    2123               0 :             nsCString version;
    2124               0 :             nsCString buildID;
    2125                 : 
    2126               0 :             if ((!(Read((&(version)), (&(__msg)), (&(__iter)))))) {
    2127               0 :                 FatalError("error deserializing (better message TODO)");
    2128               0 :                 return MsgValueError;
    2129                 :             }
    2130               0 :             if ((!(Read((&(buildID)), (&(__msg)), (&(__iter)))))) {
    2131               0 :                 FatalError("error deserializing (better message TODO)");
    2132               0 :                 return MsgValueError;
    2133                 :             }
    2134               0 :             (__msg).EndRead(__iter);
    2135               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_AppInfo__ID), (&(mState)))))) {
    2136               0 :                 NS_WARNING("bad state transition!");
    2137                 :             }
    2138               0 :             if ((!(RecvAppInfo(version, buildID)))) {
    2139               0 :                 return MsgProcessingError;
    2140                 :             }
    2141                 : 
    2142               0 :             return MsgProcessed;
    2143                 :         }
    2144                 :     case PContent::Msg_SetID__ID:
    2145                 :         {
    2146               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_SetID");
    2147               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2148               0 :                 (static_cast<const PContent::Msg_SetID*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2149                 :             }
    2150                 : 
    2151               0 :             void* __iter = 0;
    2152                 :             PRUint64 id;
    2153                 : 
    2154               0 :             if ((!(Read((&(id)), (&(__msg)), (&(__iter)))))) {
    2155               0 :                 FatalError("error deserializing (better message TODO)");
    2156               0 :                 return MsgValueError;
    2157                 :             }
    2158               0 :             (__msg).EndRead(__iter);
    2159               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_SetID__ID), (&(mState)))))) {
    2160               0 :                 NS_WARNING("bad state transition!");
    2161                 :             }
    2162               0 :             if ((!(RecvSetID(id)))) {
    2163               0 :                 return MsgProcessingError;
    2164                 :             }
    2165                 : 
    2166               0 :             return MsgProcessed;
    2167                 :         }
    2168                 :     case PContent::Reply_PAudioConstructor__ID:
    2169                 :         {
    2170               0 :             return MsgProcessed;
    2171                 :         }
    2172                 :     case PContent::Reply_PHalConstructor__ID:
    2173                 :         {
    2174               0 :             return MsgProcessed;
    2175                 :         }
    2176                 :     case PContent::Reply_PNeckoConstructor__ID:
    2177                 :         {
    2178               0 :             return MsgProcessed;
    2179                 :         }
    2180                 :     case PContent::Reply_PSmsConstructor__ID:
    2181                 :         {
    2182               0 :             return MsgProcessed;
    2183                 :         }
    2184                 :     case PContent::Reply_PStorageConstructor__ID:
    2185                 :         {
    2186               0 :             return MsgProcessed;
    2187                 :         }
    2188                 :     case PContent::Reply_PExternalHelperAppConstructor__ID:
    2189                 :         {
    2190               0 :             return MsgProcessed;
    2191                 :         }
    2192                 :     case PContent::Msg_AsyncMessage__ID:
    2193                 :         {
    2194               0 :             (const_cast<Message&>(__msg)).set_name("PContent::Msg_AsyncMessage");
    2195               0 :             if (mozilla::ipc::LoggingEnabled()) {
    2196               0 :                 (static_cast<const PContent::Msg_AsyncMessage*>((&(__msg))))->Log("[PContentChild] Received ", stderr);
    2197                 :             }
    2198                 : 
    2199               0 :             void* __iter = 0;
    2200               0 :             nsString aMessage;
    2201               0 :             nsString aJSON;
    2202                 : 
    2203               0 :             if ((!(Read((&(aMessage)), (&(__msg)), (&(__iter)))))) {
    2204               0 :                 FatalError("error deserializing (better message TODO)");
    2205               0 :                 return MsgValueError;
    2206                 :             }
    2207               0 :             if ((!(Read((&(aJSON)), (&(__msg)), (&(__iter)))))) {
    2208               0 :                 FatalError("error deserializing (better message TODO)");
    2209               0 :                 return MsgValueError;
    2210                 :             }
    2211               0 :             (__msg).EndRead(__iter);
    2212               0 :             if ((!(PContent::Transition(mState, Trigger(Trigger::Send, PContent::Msg_AsyncMessage__ID), (&(mState)))))) {
    2213               0 :                 NS_WARNING("bad state transition!");
    2214                 :             }
    2215               0 :             if ((!(RecvAsyncMessage(aMessage, aJSON)))) {
    2216               0 :                 return MsgProcessingError;
    2217                 :             }
    2218                 : 
    2219               0 :             return MsgProcessed;
    2220                 :         }
    2221                 :     default:
    2222                 :         {
    2223               0 :             return MsgNotKnown;
    2224                 :         }
    2225                 :     case SHMEM_CREATED_MESSAGE_TYPE:
    2226                 :         {
    2227                 :             Shmem::id_t id;
    2228               0 :             nsAutoPtr<Shmem::SharedMemory> rawmem(Shmem::OpenExisting(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), __msg, (&(id)), true));
    2229               0 :             if ((!(rawmem))) {
    2230               0 :                 return MsgPayloadError;
    2231                 :             }
    2232               0 :             (mShmemMap).AddWithID((rawmem).forget(), id);
    2233                 : 
    2234               0 :             return MsgProcessed;
    2235                 :         }
    2236                 :     case SHMEM_DESTROYED_MESSAGE_TYPE:
    2237                 :         {
    2238                 :             Shmem::id_t id;
    2239               0 :             void* iter = 0;
    2240               0 :             if ((!(IPC::ReadParam((&(__msg)), (&(iter)), (&(id)))))) {
    2241               0 :                 return MsgPayloadError;
    2242                 :             }
    2243               0 :             (__msg).EndRead(iter);
    2244                 : 
    2245               0 :             Shmem::SharedMemory* rawmem = LookupSharedMemory(id);
    2246               0 :             if ((!(rawmem))) {
    2247               0 :                 return MsgValueError;
    2248                 :             }
    2249               0 :             (mShmemMap).Remove(id);
    2250               0 :             Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem);
    2251               0 :             return MsgProcessed;
    2252                 :         }
    2253                 :     }
    2254                 : }
    2255                 : 
    2256                 : PContentChild::Result
    2257               0 : PContentChild::OnMessageReceived(
    2258                 :         const Message& __msg,
    2259                 :         Message*& __reply)
    2260                 : {
    2261               0 :     int32 __route = (__msg).routing_id();
    2262               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
    2263               0 :         ChannelListener* __routed = Lookup(__route);
    2264               0 :         if ((!(__routed))) {
    2265               0 :             return MsgRouteError;
    2266                 :         }
    2267               0 :         return (__routed)->OnMessageReceived(__msg, __reply);
    2268                 :     }
    2269                 : 
    2270               0 :     return MsgNotKnown;
    2271                 : }
    2272                 : 
    2273                 : PContentChild::Result
    2274               0 : PContentChild::OnCallReceived(
    2275                 :         const Message& __msg,
    2276                 :         Message*& __reply)
    2277                 : {
    2278               0 :     int32 __route = (__msg).routing_id();
    2279               0 :     if ((MSG_ROUTING_CONTROL) != (__route)) {
    2280               0 :         ChannelListener* __routed = Lookup(__route);
    2281               0 :         if ((!(__routed))) {
    2282               0 :             return MsgRouteError;
    2283                 :         }
    2284               0 :         return (__routed)->OnCallReceived(__msg, __reply);
    2285                 :     }
    2286                 : 
    2287               0 :     return MsgNotKnown;
    2288                 : }
    2289                 : 
    2290                 : void
    2291               0 : PContentChild::OnProcessingError(Result code)
    2292                 : {
    2293               0 :     return ProcessingError(code);
    2294                 : }
    2295                 : 
    2296                 : bool
    2297               0 : PContentChild::OnReplyTimeout()
    2298                 : {
    2299               0 :     return ShouldContinueFromReplyTimeout();
    2300                 : }
    2301                 : 
    2302                 : void
    2303               0 : PContentChild::OnEnteredCxxStack()
    2304                 : {
    2305               0 :     return EnteredCxxStack();
    2306                 : }
    2307                 : 
    2308                 : void
    2309               0 : PContentChild::OnExitedCxxStack()
    2310                 : {
    2311               0 :     return ExitedCxxStack();
    2312                 : }
    2313                 : 
    2314                 : void
    2315               0 : PContentChild::OnEnteredCall()
    2316                 : {
    2317               0 :     return EnteredCall();
    2318                 : }
    2319                 : 
    2320                 : void
    2321               0 : PContentChild::OnExitedCall()
    2322                 : {
    2323               0 :     return ExitedCall();
    2324                 : }
    2325                 : 
    2326                 : bool
    2327               0 : PContentChild::IsOnCxxStack() const
    2328                 : {
    2329               0 :     return (mChannel).IsOnCxxStack();
    2330                 : }
    2331                 : 
    2332                 : void
    2333               0 : PContentChild::FlushPendingRPCQueue()
    2334                 : {
    2335               0 :     ((this)->mChannel).FlushPendingRPCQueue();
    2336               0 : }
    2337                 : 
    2338                 : void
    2339               0 : PContentChild::OnChannelClose()
    2340                 : {
    2341               0 :     DestroySubtree(NormalShutdown);
    2342               0 :     DeallocSubtree();
    2343               0 :     DeallocShmems();
    2344               0 : }
    2345                 : 
    2346                 : void
    2347               0 : PContentChild::OnChannelError()
    2348                 : {
    2349               0 :     DestroySubtree(AbnormalShutdown);
    2350               0 :     DeallocSubtree();
    2351               0 :     DeallocShmems();
    2352               0 : }
    2353                 : 
    2354                 : void
    2355               0 : PContentChild::OnChannelConnected(int32 pid)
    2356                 : {
    2357               0 : }
    2358                 : 
    2359                 : bool
    2360               0 : PContentChild::AllocShmem(
    2361                 :         size_t aSize,
    2362                 :         Shmem::SharedMemory::SharedMemoryType aType,
    2363                 :         Shmem* aMem)
    2364                 : {
    2365                 :     Shmem::id_t aId;
    2366               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
    2367               0 :     if ((!(rawmem))) {
    2368               0 :         return false;
    2369                 :     }
    2370                 : 
    2371               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
    2372               0 :     return true;
    2373                 : }
    2374                 : 
    2375                 : bool
    2376               0 : PContentChild::AllocUnsafeShmem(
    2377                 :         size_t aSize,
    2378                 :         Shmem::SharedMemory::SharedMemoryType aType,
    2379                 :         Shmem* aMem)
    2380                 : {
    2381                 :     Shmem::id_t aId;
    2382               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
    2383               0 :     if ((!(rawmem))) {
    2384               0 :         return false;
    2385                 :     }
    2386                 : 
    2387               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
    2388               0 :     return true;
    2389                 : }
    2390                 : 
    2391                 : bool
    2392               0 : PContentChild::AdoptShmem(
    2393                 :         Shmem& aMem,
    2394                 :         Shmem* aOutMem)
    2395                 : {
    2396               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    2397               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
    2398               0 :         NS_RUNTIMEABORT("bad Shmem");
    2399                 :     }
    2400                 : 
    2401                 :     Shmem::id_t aId;
    2402               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
    2403               0 :         return false;
    2404                 :     }
    2405                 : 
    2406               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
    2407               0 :     return true;
    2408                 : }
    2409                 : 
    2410                 : bool
    2411               0 : PContentChild::DeallocShmem(Shmem& aMem)
    2412                 : {
    2413               0 :     bool ok = DestroySharedMemory(aMem);
    2414               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    2415               0 :     return ok;
    2416                 : }
    2417                 : 
    2418                 : void
    2419               0 : PContentChild::ProcessNativeEventsInRPCCall()
    2420                 : {
    2421                 : #ifdef OS_WIN
    2422                 :     (mChannel).ProcessNativeEventsInRPCCall();
    2423                 : #else 
    2424               0 :     NS_RUNTIMEABORT("This method is Windows-only");
    2425                 : #endif 
    2426               0 : }
    2427                 : 
    2428                 : void
    2429               0 : PContentChild::FatalError(const char* const msg) const
    2430                 : {
    2431                 :     // Virtual method to prevent inlining.
    2432                 :     // This give us better error reporting.
    2433                 :     // See bug 589371
    2434                 : 
    2435               0 :     NS_ERROR("IPDL error:");
    2436               0 :     NS_ERROR(msg);
    2437                 : 
    2438               0 :     NS_RUNTIMEABORT("[PContentChild] abort()ing as a result");
    2439               0 : }
    2440                 : 
    2441                 : void
    2442               0 : PContentChild::DestroySubtree(ActorDestroyReason why)
    2443                 : {
    2444               0 :     ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
    2445                 : 
    2446                 :     {
    2447                 :         // Recursively shutting down PAudio kids
    2448               0 :         InfallibleTArray<PAudioChild*> kids = mManagedPAudioChild;
    2449               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2450               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2451                 :         }
    2452                 :     }
    2453                 :     {
    2454                 :         // Recursively shutting down PBrowser kids
    2455               0 :         InfallibleTArray<PBrowserChild*> kids = mManagedPBrowserChild;
    2456               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2457               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2458                 :         }
    2459                 :     }
    2460                 :     {
    2461                 :         // Recursively shutting down PCrashReporter kids
    2462               0 :         InfallibleTArray<PCrashReporterChild*> kids = mManagedPCrashReporterChild;
    2463               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2464               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2465                 :         }
    2466                 :     }
    2467                 :     {
    2468                 :         // Recursively shutting down PExternalHelperApp kids
    2469               0 :         InfallibleTArray<PExternalHelperAppChild*> kids = mManagedPExternalHelperAppChild;
    2470               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2471               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2472                 :         }
    2473                 :     }
    2474                 :     {
    2475                 :         // Recursively shutting down PHal kids
    2476               0 :         InfallibleTArray<PHalChild*> kids = mManagedPHalChild;
    2477               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2478               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2479                 :         }
    2480                 :     }
    2481                 :     {
    2482                 :         // Recursively shutting down PMemoryReportRequest kids
    2483               0 :         InfallibleTArray<PMemoryReportRequestChild*> kids = mManagedPMemoryReportRequestChild;
    2484               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2485               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2486                 :         }
    2487                 :     }
    2488                 :     {
    2489                 :         // Recursively shutting down PNecko kids
    2490               0 :         InfallibleTArray<PNeckoChild*> kids = mManagedPNeckoChild;
    2491               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2492               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2493                 :         }
    2494                 :     }
    2495                 :     {
    2496                 :         // Recursively shutting down PSms kids
    2497               0 :         InfallibleTArray<PSmsChild*> kids = mManagedPSmsChild;
    2498               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2499               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2500                 :         }
    2501                 :     }
    2502                 :     {
    2503                 :         // Recursively shutting down PStorage kids
    2504               0 :         InfallibleTArray<PStorageChild*> kids = mManagedPStorageChild;
    2505               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2506               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2507                 :         }
    2508                 :     }
    2509                 :     {
    2510                 :         // Recursively shutting down PTestShell kids
    2511               0 :         InfallibleTArray<PTestShellChild*> kids = mManagedPTestShellChild;
    2512               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2513               0 :             (kids[i])->DestroySubtree(subtreewhy);
    2514                 :         }
    2515                 :     }
    2516                 : 
    2517                 :     // Finally, destroy "us".
    2518               0 :     ActorDestroy(why);
    2519               0 : }
    2520                 : 
    2521                 : void
    2522               0 : PContentChild::DeallocSubtree()
    2523                 : {
    2524                 :     {
    2525                 :         // Recursively deleting PAudio kids
    2526               0 :         InfallibleTArray<PAudioChild*>& kids = mManagedPAudioChild;
    2527               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2528               0 :             (kids[i])->DeallocSubtree();
    2529                 :         }
    2530                 : 
    2531               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2532               0 :             DeallocPAudio(kids[i]);
    2533                 :         }
    2534               0 :         (mManagedPAudioChild).Clear();
    2535                 :     }
    2536                 :     {
    2537                 :         // Recursively deleting PBrowser kids
    2538               0 :         InfallibleTArray<PBrowserChild*>& kids = mManagedPBrowserChild;
    2539               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2540               0 :             (kids[i])->DeallocSubtree();
    2541                 :         }
    2542                 : 
    2543               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2544               0 :             DeallocPBrowser(kids[i]);
    2545                 :         }
    2546               0 :         (mManagedPBrowserChild).Clear();
    2547                 :     }
    2548                 :     {
    2549                 :         // Recursively deleting PCrashReporter kids
    2550               0 :         InfallibleTArray<PCrashReporterChild*>& kids = mManagedPCrashReporterChild;
    2551               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2552               0 :             (kids[i])->DeallocSubtree();
    2553                 :         }
    2554                 : 
    2555               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2556               0 :             DeallocPCrashReporter(kids[i]);
    2557                 :         }
    2558               0 :         (mManagedPCrashReporterChild).Clear();
    2559                 :     }
    2560                 :     {
    2561                 :         // Recursively deleting PExternalHelperApp kids
    2562               0 :         InfallibleTArray<PExternalHelperAppChild*>& kids = mManagedPExternalHelperAppChild;
    2563               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2564               0 :             (kids[i])->DeallocSubtree();
    2565                 :         }
    2566                 : 
    2567               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2568               0 :             DeallocPExternalHelperApp(kids[i]);
    2569                 :         }
    2570               0 :         (mManagedPExternalHelperAppChild).Clear();
    2571                 :     }
    2572                 :     {
    2573                 :         // Recursively deleting PHal kids
    2574               0 :         InfallibleTArray<PHalChild*>& kids = mManagedPHalChild;
    2575               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2576               0 :             (kids[i])->DeallocSubtree();
    2577                 :         }
    2578                 : 
    2579               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2580               0 :             DeallocPHal(kids[i]);
    2581                 :         }
    2582               0 :         (mManagedPHalChild).Clear();
    2583                 :     }
    2584                 :     {
    2585                 :         // Recursively deleting PMemoryReportRequest kids
    2586               0 :         InfallibleTArray<PMemoryReportRequestChild*>& kids = mManagedPMemoryReportRequestChild;
    2587               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2588               0 :             (kids[i])->DeallocSubtree();
    2589                 :         }
    2590                 : 
    2591               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2592               0 :             DeallocPMemoryReportRequest(kids[i]);
    2593                 :         }
    2594               0 :         (mManagedPMemoryReportRequestChild).Clear();
    2595                 :     }
    2596                 :     {
    2597                 :         // Recursively deleting PNecko kids
    2598               0 :         InfallibleTArray<PNeckoChild*>& kids = mManagedPNeckoChild;
    2599               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2600               0 :             (kids[i])->DeallocSubtree();
    2601                 :         }
    2602                 : 
    2603               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2604               0 :             DeallocPNecko(kids[i]);
    2605                 :         }
    2606               0 :         (mManagedPNeckoChild).Clear();
    2607                 :     }
    2608                 :     {
    2609                 :         // Recursively deleting PSms kids
    2610               0 :         InfallibleTArray<PSmsChild*>& kids = mManagedPSmsChild;
    2611               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2612               0 :             (kids[i])->DeallocSubtree();
    2613                 :         }
    2614                 : 
    2615               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2616               0 :             DeallocPSms(kids[i]);
    2617                 :         }
    2618               0 :         (mManagedPSmsChild).Clear();
    2619                 :     }
    2620                 :     {
    2621                 :         // Recursively deleting PStorage kids
    2622               0 :         InfallibleTArray<PStorageChild*>& kids = mManagedPStorageChild;
    2623               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2624               0 :             (kids[i])->DeallocSubtree();
    2625                 :         }
    2626                 : 
    2627               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2628               0 :             DeallocPStorage(kids[i]);
    2629                 :         }
    2630               0 :         (mManagedPStorageChild).Clear();
    2631                 :     }
    2632                 :     {
    2633                 :         // Recursively deleting PTestShell kids
    2634               0 :         InfallibleTArray<PTestShellChild*>& kids = mManagedPTestShellChild;
    2635               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2636               0 :             (kids[i])->DeallocSubtree();
    2637                 :         }
    2638                 : 
    2639               0 :         for (uint32 i = 0; (i) < ((kids).Length()); (++(i))) {
    2640               0 :             DeallocPTestShell(kids[i]);
    2641                 :         }
    2642               0 :         (mManagedPTestShellChild).Clear();
    2643                 :     }
    2644               0 : }
    2645                 : 
    2646                 : void
    2647               0 : PContentChild::DeallocShmems()
    2648                 : {
    2649               0 :     for (IDMap<SharedMemory>::const_iterator cit = (mShmemMap).begin(); (cit) != ((mShmemMap).end()); (++(cit))) {
    2650               0 :         Shmem::Dealloc(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (cit)->second);
    2651                 :     }
    2652               0 :     (mShmemMap).Clear();
    2653               0 : }
    2654                 : 
    2655                 : void
    2656               0 : PContentChild::Write(
    2657                 :         const StorageConstructData& __v,
    2658                 :         Message* __msg)
    2659                 : {
    2660                 :     typedef StorageConstructData __type;
    2661               0 :     Write(int((__v).type()), __msg);
    2662                 : 
    2663               0 :     switch ((__v).type()) {
    2664                 :     case __type::Tnull_t:
    2665                 :         {
    2666               0 :             Write((__v).get_null_t(), __msg);
    2667               0 :             return;
    2668                 :         }
    2669                 :     case __type::TStorageClone:
    2670                 :         {
    2671               0 :             Write((__v).get_StorageClone(), __msg);
    2672               0 :             return;
    2673                 :         }
    2674                 :     default:
    2675                 :         {
    2676               0 :             NS_RUNTIMEABORT("unknown union type");
    2677               0 :             return;
    2678                 :         }
    2679                 :     }
    2680                 : }
    2681                 : 
    2682                 : bool
    2683               0 : PContentChild::Read(
    2684                 :         StorageConstructData* __v,
    2685                 :         const Message* __msg,
    2686                 :         void** __iter)
    2687                 : {
    2688                 :     typedef StorageConstructData __type;
    2689                 :     int type;
    2690               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
    2691               0 :         return false;
    2692                 :     }
    2693                 : 
    2694               0 :     switch (type) {
    2695                 :     case __type::Tnull_t:
    2696                 :         {
    2697               0 :             null_t tmp = null_t();
    2698               0 :             (*(__v)) = tmp;
    2699               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
    2700                 :         }
    2701                 :     case __type::TStorageClone:
    2702                 :         {
    2703               0 :             StorageClone tmp = StorageClone();
    2704               0 :             (*(__v)) = tmp;
    2705               0 :             return Read((&((__v)->get_StorageClone())), __msg, __iter);
    2706                 :         }
    2707                 :     default:
    2708                 :         {
    2709               0 :             return false;
    2710                 :         }
    2711                 :     }
    2712                 : }
    2713                 : 
    2714                 : void
    2715               0 : PContentChild::Write(
    2716                 :         const StorageClone& __v,
    2717                 :         Message* __msg)
    2718                 : {
    2719                 :     // skipping actor field that's meaningless on this side
    2720               0 :     Write((__v).actorChild(), __msg, false);
    2721               0 :     Write((__v).callerSecure(), __msg);
    2722               0 : }
    2723                 : 
    2724                 : bool
    2725               0 : PContentChild::Read(
    2726                 :         StorageClone* __v,
    2727                 :         const Message* __msg,
    2728                 :         void** __iter)
    2729                 : {
    2730                 :     // skipping actor field that's meaningless on this side
    2731               0 :     if ((!(Read((&((__v)->actorChild())), __msg, __iter, false)))) {
    2732               0 :         return false;
    2733                 :     }
    2734               0 :     if ((!(Read((&((__v)->callerSecure())), __msg, __iter)))) {
    2735               0 :         return false;
    2736                 :     }
    2737               0 :     return true;
    2738                 : }
    2739                 : 
    2740                 : void
    2741               0 : PContentChild::Write(
    2742                 :         PStorageChild* __v,
    2743                 :         Message* __msg,
    2744                 :         bool __nullable)
    2745                 : {
    2746                 :     int32 id;
    2747               0 :     if ((!(__v))) {
    2748               0 :         if ((!(__nullable))) {
    2749               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    2750                 :         }
    2751               0 :         id = 0;
    2752                 :     }
    2753                 :     else {
    2754               0 :         id = (__v)->mId;
    2755               0 :         if ((1) == (id)) {
    2756               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    2757                 :         }
    2758                 :     }
    2759                 : 
    2760               0 :     Write(id, __msg);
    2761               0 : }
    2762                 : 
    2763                 : bool
    2764               0 : PContentChild::Read(
    2765                 :         PStorageChild** __v,
    2766                 :         const Message* __msg,
    2767                 :         void** __iter,
    2768                 :         bool __nullable)
    2769                 : {
    2770                 :     int32 id;
    2771               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    2772               0 :         return false;
    2773                 :     }
    2774               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    2775               0 :         return false;
    2776                 :     }
    2777                 : 
    2778               0 :     if ((0) == (id)) {
    2779               0 :         (*(__v)) = 0;
    2780                 :     }
    2781                 :     else {
    2782               0 :         (*(__v)) = static_cast<PStorageChild*>(Lookup(id));
    2783               0 :         if ((!((*(__v))))) {
    2784               0 :             return false;
    2785                 :         }
    2786                 :     }
    2787               0 :     return true;
    2788                 : }
    2789                 : 
    2790                 : void
    2791               0 : PContentChild::Write(
    2792                 :         PBrowserChild* __v,
    2793                 :         Message* __msg,
    2794                 :         bool __nullable)
    2795                 : {
    2796                 :     int32 id;
    2797               0 :     if ((!(__v))) {
    2798               0 :         if ((!(__nullable))) {
    2799               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    2800                 :         }
    2801               0 :         id = 0;
    2802                 :     }
    2803                 :     else {
    2804               0 :         id = (__v)->mId;
    2805               0 :         if ((1) == (id)) {
    2806               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    2807                 :         }
    2808                 :     }
    2809                 : 
    2810               0 :     Write(id, __msg);
    2811               0 : }
    2812                 : 
    2813                 : bool
    2814               0 : PContentChild::Read(
    2815                 :         PBrowserChild** __v,
    2816                 :         const Message* __msg,
    2817                 :         void** __iter,
    2818                 :         bool __nullable)
    2819                 : {
    2820                 :     int32 id;
    2821               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    2822               0 :         return false;
    2823                 :     }
    2824               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    2825               0 :         return false;
    2826                 :     }
    2827                 : 
    2828               0 :     if ((0) == (id)) {
    2829               0 :         (*(__v)) = 0;
    2830                 :     }
    2831                 :     else {
    2832               0 :         (*(__v)) = static_cast<PBrowserChild*>(Lookup(id));
    2833               0 :         if ((!((*(__v))))) {
    2834               0 :             return false;
    2835                 :         }
    2836                 :     }
    2837               0 :     return true;
    2838                 : }
    2839                 : 
    2840                 : void
    2841               0 : PContentChild::Write(
    2842                 :         PExternalHelperAppChild* __v,
    2843                 :         Message* __msg,
    2844                 :         bool __nullable)
    2845                 : {
    2846                 :     int32 id;
    2847               0 :     if ((!(__v))) {
    2848               0 :         if ((!(__nullable))) {
    2849               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    2850                 :         }
    2851               0 :         id = 0;
    2852                 :     }
    2853                 :     else {
    2854               0 :         id = (__v)->mId;
    2855               0 :         if ((1) == (id)) {
    2856               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    2857                 :         }
    2858                 :     }
    2859                 : 
    2860               0 :     Write(id, __msg);
    2861               0 : }
    2862                 : 
    2863                 : bool
    2864               0 : PContentChild::Read(
    2865                 :         PExternalHelperAppChild** __v,
    2866                 :         const Message* __msg,
    2867                 :         void** __iter,
    2868                 :         bool __nullable)
    2869                 : {
    2870                 :     int32 id;
    2871               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    2872               0 :         return false;
    2873                 :     }
    2874               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    2875               0 :         return false;
    2876                 :     }
    2877                 : 
    2878               0 :     if ((0) == (id)) {
    2879               0 :         (*(__v)) = 0;
    2880                 :     }
    2881                 :     else {
    2882               0 :         (*(__v)) = static_cast<PExternalHelperAppChild*>(Lookup(id));
    2883               0 :         if ((!((*(__v))))) {
    2884               0 :             return false;
    2885                 :         }
    2886                 :     }
    2887               0 :     return true;
    2888                 : }
    2889                 : 
    2890                 : void
    2891               0 : PContentChild::Write(
    2892                 :         const FontListEntry& __v,
    2893                 :         Message* __msg)
    2894                 : {
    2895               0 :     Write((__v).familyName(), __msg);
    2896               0 :     Write((__v).faceName(), __msg);
    2897               0 :     Write((__v).filepath(), __msg);
    2898               0 :     Write((__v).weight(), __msg);
    2899               0 :     Write((__v).stretch(), __msg);
    2900               0 :     Write((__v).italic(), __msg);
    2901               0 :     Write((__v).index(), __msg);
    2902               0 : }
    2903                 : 
    2904                 : bool
    2905               0 : PContentChild::Read(
    2906                 :         FontListEntry* __v,
    2907                 :         const Message* __msg,
    2908                 :         void** __iter)
    2909                 : {
    2910               0 :     if ((!(Read((&((__v)->familyName())), __msg, __iter)))) {
    2911               0 :         return false;
    2912                 :     }
    2913               0 :     if ((!(Read((&((__v)->faceName())), __msg, __iter)))) {
    2914               0 :         return false;
    2915                 :     }
    2916               0 :     if ((!(Read((&((__v)->filepath())), __msg, __iter)))) {
    2917               0 :         return false;
    2918                 :     }
    2919               0 :     if ((!(Read((&((__v)->weight())), __msg, __iter)))) {
    2920               0 :         return false;
    2921                 :     }
    2922               0 :     if ((!(Read((&((__v)->stretch())), __msg, __iter)))) {
    2923               0 :         return false;
    2924                 :     }
    2925               0 :     if ((!(Read((&((__v)->italic())), __msg, __iter)))) {
    2926               0 :         return false;
    2927                 :     }
    2928               0 :     if ((!(Read((&((__v)->index())), __msg, __iter)))) {
    2929               0 :         return false;
    2930                 :     }
    2931               0 :     return true;
    2932                 : }
    2933                 : 
    2934                 : void
    2935               0 : PContentChild::Write(
    2936                 :         PTestShellChild* __v,
    2937                 :         Message* __msg,
    2938                 :         bool __nullable)
    2939                 : {
    2940                 :     int32 id;
    2941               0 :     if ((!(__v))) {
    2942               0 :         if ((!(__nullable))) {
    2943               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    2944                 :         }
    2945               0 :         id = 0;
    2946                 :     }
    2947                 :     else {
    2948               0 :         id = (__v)->mId;
    2949               0 :         if ((1) == (id)) {
    2950               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    2951                 :         }
    2952                 :     }
    2953                 : 
    2954               0 :     Write(id, __msg);
    2955               0 : }
    2956                 : 
    2957                 : bool
    2958               0 : PContentChild::Read(
    2959                 :         PTestShellChild** __v,
    2960                 :         const Message* __msg,
    2961                 :         void** __iter,
    2962                 :         bool __nullable)
    2963                 : {
    2964                 :     int32 id;
    2965               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    2966               0 :         return false;
    2967                 :     }
    2968               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    2969               0 :         return false;
    2970                 :     }
    2971                 : 
    2972               0 :     if ((0) == (id)) {
    2973               0 :         (*(__v)) = 0;
    2974                 :     }
    2975                 :     else {
    2976               0 :         (*(__v)) = static_cast<PTestShellChild*>(Lookup(id));
    2977               0 :         if ((!((*(__v))))) {
    2978               0 :             return false;
    2979                 :         }
    2980                 :     }
    2981               0 :     return true;
    2982                 : }
    2983                 : 
    2984                 : void
    2985               0 : PContentChild::Write(
    2986                 :         PAudioChild* __v,
    2987                 :         Message* __msg,
    2988                 :         bool __nullable)
    2989                 : {
    2990                 :     int32 id;
    2991               0 :     if ((!(__v))) {
    2992               0 :         if ((!(__nullable))) {
    2993               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    2994                 :         }
    2995               0 :         id = 0;
    2996                 :     }
    2997                 :     else {
    2998               0 :         id = (__v)->mId;
    2999               0 :         if ((1) == (id)) {
    3000               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3001                 :         }
    3002                 :     }
    3003                 : 
    3004               0 :     Write(id, __msg);
    3005               0 : }
    3006                 : 
    3007                 : bool
    3008               0 : PContentChild::Read(
    3009                 :         PAudioChild** __v,
    3010                 :         const Message* __msg,
    3011                 :         void** __iter,
    3012                 :         bool __nullable)
    3013                 : {
    3014                 :     int32 id;
    3015               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3016               0 :         return false;
    3017                 :     }
    3018               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3019               0 :         return false;
    3020                 :     }
    3021                 : 
    3022               0 :     if ((0) == (id)) {
    3023               0 :         (*(__v)) = 0;
    3024                 :     }
    3025                 :     else {
    3026               0 :         (*(__v)) = static_cast<PAudioChild*>(Lookup(id));
    3027               0 :         if ((!((*(__v))))) {
    3028               0 :             return false;
    3029                 :         }
    3030                 :     }
    3031               0 :     return true;
    3032                 : }
    3033                 : 
    3034                 : void
    3035               0 : PContentChild::Write(
    3036                 :         PMemoryReportRequestChild* __v,
    3037                 :         Message* __msg,
    3038                 :         bool __nullable)
    3039                 : {
    3040                 :     int32 id;
    3041               0 :     if ((!(__v))) {
    3042               0 :         if ((!(__nullable))) {
    3043               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    3044                 :         }
    3045               0 :         id = 0;
    3046                 :     }
    3047                 :     else {
    3048               0 :         id = (__v)->mId;
    3049               0 :         if ((1) == (id)) {
    3050               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3051                 :         }
    3052                 :     }
    3053                 : 
    3054               0 :     Write(id, __msg);
    3055               0 : }
    3056                 : 
    3057                 : bool
    3058               0 : PContentChild::Read(
    3059                 :         PMemoryReportRequestChild** __v,
    3060                 :         const Message* __msg,
    3061                 :         void** __iter,
    3062                 :         bool __nullable)
    3063                 : {
    3064                 :     int32 id;
    3065               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3066               0 :         return false;
    3067                 :     }
    3068               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3069               0 :         return false;
    3070                 :     }
    3071                 : 
    3072               0 :     if ((0) == (id)) {
    3073               0 :         (*(__v)) = 0;
    3074                 :     }
    3075                 :     else {
    3076               0 :         (*(__v)) = static_cast<PMemoryReportRequestChild*>(Lookup(id));
    3077               0 :         if ((!((*(__v))))) {
    3078               0 :             return false;
    3079                 :         }
    3080                 :     }
    3081               0 :     return true;
    3082                 : }
    3083                 : 
    3084                 : void
    3085               0 : PContentChild::Write(
    3086                 :         PCrashReporterChild* __v,
    3087                 :         Message* __msg,
    3088                 :         bool __nullable)
    3089                 : {
    3090                 :     int32 id;
    3091               0 :     if ((!(__v))) {
    3092               0 :         if ((!(__nullable))) {
    3093               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    3094                 :         }
    3095               0 :         id = 0;
    3096                 :     }
    3097                 :     else {
    3098               0 :         id = (__v)->mId;
    3099               0 :         if ((1) == (id)) {
    3100               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3101                 :         }
    3102                 :     }
    3103                 : 
    3104               0 :     Write(id, __msg);
    3105               0 : }
    3106                 : 
    3107                 : bool
    3108               0 : PContentChild::Read(
    3109                 :         PCrashReporterChild** __v,
    3110                 :         const Message* __msg,
    3111                 :         void** __iter,
    3112                 :         bool __nullable)
    3113                 : {
    3114                 :     int32 id;
    3115               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3116               0 :         return false;
    3117                 :     }
    3118               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3119               0 :         return false;
    3120                 :     }
    3121                 : 
    3122               0 :     if ((0) == (id)) {
    3123               0 :         (*(__v)) = 0;
    3124                 :     }
    3125                 :     else {
    3126               0 :         (*(__v)) = static_cast<PCrashReporterChild*>(Lookup(id));
    3127               0 :         if ((!((*(__v))))) {
    3128               0 :             return false;
    3129                 :         }
    3130                 :     }
    3131               0 :     return true;
    3132                 : }
    3133                 : 
    3134                 : void
    3135               0 : PContentChild::Write(
    3136                 :         PSmsChild* __v,
    3137                 :         Message* __msg,
    3138                 :         bool __nullable)
    3139                 : {
    3140                 :     int32 id;
    3141               0 :     if ((!(__v))) {
    3142               0 :         if ((!(__nullable))) {
    3143               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    3144                 :         }
    3145               0 :         id = 0;
    3146                 :     }
    3147                 :     else {
    3148               0 :         id = (__v)->mId;
    3149               0 :         if ((1) == (id)) {
    3150               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3151                 :         }
    3152                 :     }
    3153                 : 
    3154               0 :     Write(id, __msg);
    3155               0 : }
    3156                 : 
    3157                 : bool
    3158               0 : PContentChild::Read(
    3159                 :         PSmsChild** __v,
    3160                 :         const Message* __msg,
    3161                 :         void** __iter,
    3162                 :         bool __nullable)
    3163                 : {
    3164                 :     int32 id;
    3165               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3166               0 :         return false;
    3167                 :     }
    3168               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3169               0 :         return false;
    3170                 :     }
    3171                 : 
    3172               0 :     if ((0) == (id)) {
    3173               0 :         (*(__v)) = 0;
    3174                 :     }
    3175                 :     else {
    3176               0 :         (*(__v)) = static_cast<PSmsChild*>(Lookup(id));
    3177               0 :         if ((!((*(__v))))) {
    3178               0 :             return false;
    3179                 :         }
    3180                 :     }
    3181               0 :     return true;
    3182                 : }
    3183                 : 
    3184                 : void
    3185               0 : PContentChild::Write(
    3186                 :         const InfallibleTArray<FontListEntry>& __v,
    3187                 :         Message* __msg)
    3188                 : {
    3189               0 :     uint32 length = (__v).Length();
    3190               0 :     Write(length, __msg);
    3191                 : 
    3192               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
    3193               0 :         Write(__v[i], __msg);
    3194                 :     }
    3195               0 : }
    3196                 : 
    3197                 : bool
    3198               0 : PContentChild::Read(
    3199                 :         InfallibleTArray<FontListEntry>* __v,
    3200                 :         const Message* __msg,
    3201                 :         void** __iter)
    3202                 : {
    3203               0 :     InfallibleTArray<FontListEntry>& a = (*(__v));
    3204                 :     uint32 length;
    3205               0 :     if ((!(Read((&(length)), __msg, __iter)))) {
    3206               0 :         return false;
    3207                 :     }
    3208                 : 
    3209               0 :     (__v)->SetLength(length);
    3210               0 :     for (uint32 i = 0; (i) < (length); (++(i))) {
    3211               0 :         if ((!(Read((&(a[i])), __msg, __iter)))) {
    3212               0 :             return false;
    3213                 :         }
    3214                 :     }
    3215               0 :     return true;
    3216                 : }
    3217                 : 
    3218                 : void
    3219               0 : PContentChild::Write(
    3220                 :         PHalChild* __v,
    3221                 :         Message* __msg,
    3222                 :         bool __nullable)
    3223                 : {
    3224                 :     int32 id;
    3225               0 :     if ((!(__v))) {
    3226               0 :         if ((!(__nullable))) {
    3227               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    3228                 :         }
    3229               0 :         id = 0;
    3230                 :     }
    3231                 :     else {
    3232               0 :         id = (__v)->mId;
    3233               0 :         if ((1) == (id)) {
    3234               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3235                 :         }
    3236                 :     }
    3237                 : 
    3238               0 :     Write(id, __msg);
    3239               0 : }
    3240                 : 
    3241                 : bool
    3242               0 : PContentChild::Read(
    3243                 :         PHalChild** __v,
    3244                 :         const Message* __msg,
    3245                 :         void** __iter,
    3246                 :         bool __nullable)
    3247                 : {
    3248                 :     int32 id;
    3249               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3250               0 :         return false;
    3251                 :     }
    3252               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3253               0 :         return false;
    3254                 :     }
    3255                 : 
    3256               0 :     if ((0) == (id)) {
    3257               0 :         (*(__v)) = 0;
    3258                 :     }
    3259                 :     else {
    3260               0 :         (*(__v)) = static_cast<PHalChild*>(Lookup(id));
    3261               0 :         if ((!((*(__v))))) {
    3262               0 :             return false;
    3263                 :         }
    3264                 :     }
    3265               0 :     return true;
    3266                 : }
    3267                 : 
    3268                 : void
    3269               0 : PContentChild::Write(
    3270                 :         PNeckoChild* __v,
    3271                 :         Message* __msg,
    3272                 :         bool __nullable)
    3273                 : {
    3274                 :     int32 id;
    3275               0 :     if ((!(__v))) {
    3276               0 :         if ((!(__nullable))) {
    3277               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
    3278                 :         }
    3279               0 :         id = 0;
    3280                 :     }
    3281                 :     else {
    3282               0 :         id = (__v)->mId;
    3283               0 :         if ((1) == (id)) {
    3284               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
    3285                 :         }
    3286                 :     }
    3287                 : 
    3288               0 :     Write(id, __msg);
    3289               0 : }
    3290                 : 
    3291                 : bool
    3292               0 : PContentChild::Read(
    3293                 :         PNeckoChild** __v,
    3294                 :         const Message* __msg,
    3295                 :         void** __iter,
    3296                 :         bool __nullable)
    3297                 : {
    3298                 :     int32 id;
    3299               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
    3300               0 :         return false;
    3301                 :     }
    3302               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
    3303               0 :         return false;
    3304                 :     }
    3305                 : 
    3306               0 :     if ((0) == (id)) {
    3307               0 :         (*(__v)) = 0;
    3308                 :     }
    3309                 :     else {
    3310               0 :         (*(__v)) = static_cast<PNeckoChild*>(Lookup(id));
    3311               0 :         if ((!((*(__v))))) {
    3312               0 :             return false;
    3313                 :         }
    3314                 :     }
    3315               0 :     return true;
    3316                 : }
    3317                 : 
    3318                 : 
    3319                 : 
    3320                 : } // namespace dom
    3321                 : } // namespace mozilla

Generated by: LCOV version 1.7