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

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