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

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

Generated by: LCOV version 1.7