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

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

Generated by: LCOV version 1.7