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

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : 
       7                 : #include "mozilla/net/PHttpChannelChild.h"
       8                 : 
       9                 : #include "mozilla/net/PNeckoChild.h"
      10                 : 
      11                 : typedef IPC::Message Message;
      12                 : typedef mozilla::ipc::RPCChannel Channel;
      13                 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
      14                 : typedef base::ProcessHandle ProcessHandle;
      15                 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
      16                 : typedef mozilla::ipc::SharedMemory SharedMemory;
      17                 : typedef mozilla::ipc::Trigger Trigger;
      18                 : typedef mozilla::ipc::ActorHandle ActorHandle;
      19                 : typedef mozilla::ipc::Shmem Shmem;
      20                 : typedef IPC::URI URI;
      21                 : typedef IPC::InputStream InputStream;
      22                 : using mozilla::net::PNeckoChild;
      23                 : 
      24                 : namespace mozilla {
      25                 : namespace net {
      26                 : 
      27                 : 
      28                 : void
      29               0 : PHttpChannelChild::ActorDestroy(ActorDestroyReason why)
      30                 : {
      31               0 : }
      32                 : 
      33               0 : PHttpChannelChild::PHttpChannelChild() :
      34                 :     mId(0),
      35               0 :     mState(PHttpChannel::__Dead)
      36                 : {
      37               0 :     MOZ_COUNT_CTOR(PHttpChannelChild);
      38               0 : }
      39                 : 
      40               0 : PHttpChannelChild::~PHttpChannelChild()
      41                 : {
      42               0 :     MOZ_COUNT_DTOR(PHttpChannelChild);
      43               0 : }
      44                 : 
      45                 : PNeckoChild*
      46               0 : PHttpChannelChild::Manager()
      47                 : {
      48               0 :     return static_cast<PNeckoChild*>(mManager);
      49                 : }
      50                 : 
      51                 : PHttpChannel::State
      52               0 : PHttpChannelChild::state()
      53                 : {
      54               0 :     return mState;
      55                 : }
      56                 : 
      57                 : bool
      58               0 : PHttpChannelChild::SendAsyncOpen(
      59                 :         const URI& uri,
      60                 :         const URI& original,
      61                 :         const URI& doc,
      62                 :         const URI& referrer,
      63                 :         const PRUint32& loadFlags,
      64                 :         const RequestHeaderTuples& requestHeaders,
      65                 :         const nsHttpAtom& requestMethod,
      66                 :         const InputStream& uploadStream,
      67                 :         const bool& uploadStreamHasHeaders,
      68                 :         const PRUint16& priority,
      69                 :         const PRUint8& redirectionLimit,
      70                 :         const bool& allowPipelining,
      71                 :         const bool& forceAllowThirdPartyCookie,
      72                 :         const bool& resumeAt,
      73                 :         const PRUint64& startPos,
      74                 :         const nsCString& entityID,
      75                 :         const bool& chooseApplicationCache,
      76                 :         const nsCString& appCacheClientID,
      77                 :         const bool& allowSpdy)
      78                 : {
      79               0 :     PHttpChannel::Msg_AsyncOpen* __msg = new PHttpChannel::Msg_AsyncOpen();
      80                 : 
      81               0 :     Write(uri, __msg);
      82               0 :     Write(original, __msg);
      83               0 :     Write(doc, __msg);
      84               0 :     Write(referrer, __msg);
      85               0 :     Write(loadFlags, __msg);
      86               0 :     Write(requestHeaders, __msg);
      87               0 :     Write(requestMethod, __msg);
      88               0 :     Write(uploadStream, __msg);
      89               0 :     Write(uploadStreamHasHeaders, __msg);
      90               0 :     Write(priority, __msg);
      91               0 :     Write(redirectionLimit, __msg);
      92               0 :     Write(allowPipelining, __msg);
      93               0 :     Write(forceAllowThirdPartyCookie, __msg);
      94               0 :     Write(resumeAt, __msg);
      95               0 :     Write(startPos, __msg);
      96               0 :     Write(entityID, __msg);
      97               0 :     Write(chooseApplicationCache, __msg);
      98               0 :     Write(appCacheClientID, __msg);
      99               0 :     Write(allowSpdy, __msg);
     100                 : 
     101               0 :     (__msg)->set_routing_id(mId);
     102                 : 
     103                 : 
     104                 : 
     105               0 :     if (mozilla::ipc::LoggingEnabled()) {
     106               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     107                 :     }
     108               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_AsyncOpen__ID), (&(mState)))))) {
     109               0 :         NS_WARNING("bad state transition!");
     110                 :     }
     111                 : 
     112               0 :     bool __sendok = (mChannel)->Send(__msg);
     113               0 :     return __sendok;
     114                 : }
     115                 : 
     116                 : bool
     117               0 : PHttpChannelChild::SendConnectChannel(const PRUint32& channelId)
     118                 : {
     119               0 :     PHttpChannel::Msg_ConnectChannel* __msg = new PHttpChannel::Msg_ConnectChannel();
     120                 : 
     121               0 :     Write(channelId, __msg);
     122                 : 
     123               0 :     (__msg)->set_routing_id(mId);
     124                 : 
     125                 : 
     126                 : 
     127               0 :     if (mozilla::ipc::LoggingEnabled()) {
     128               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     129                 :     }
     130               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_ConnectChannel__ID), (&(mState)))))) {
     131               0 :         NS_WARNING("bad state transition!");
     132                 :     }
     133                 : 
     134               0 :     bool __sendok = (mChannel)->Send(__msg);
     135               0 :     return __sendok;
     136                 : }
     137                 : 
     138                 : bool
     139               0 : PHttpChannelChild::SendSetPriority(const PRUint16& priority)
     140                 : {
     141               0 :     PHttpChannel::Msg_SetPriority* __msg = new PHttpChannel::Msg_SetPriority();
     142                 : 
     143               0 :     Write(priority, __msg);
     144                 : 
     145               0 :     (__msg)->set_routing_id(mId);
     146                 : 
     147                 : 
     148                 : 
     149               0 :     if (mozilla::ipc::LoggingEnabled()) {
     150               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     151                 :     }
     152               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_SetPriority__ID), (&(mState)))))) {
     153               0 :         NS_WARNING("bad state transition!");
     154                 :     }
     155                 : 
     156               0 :     bool __sendok = (mChannel)->Send(__msg);
     157               0 :     return __sendok;
     158                 : }
     159                 : 
     160                 : bool
     161               0 : PHttpChannelChild::SendSetCacheTokenCachedCharset(const nsCString& charset)
     162                 : {
     163               0 :     PHttpChannel::Msg_SetCacheTokenCachedCharset* __msg = new PHttpChannel::Msg_SetCacheTokenCachedCharset();
     164                 : 
     165               0 :     Write(charset, __msg);
     166                 : 
     167               0 :     (__msg)->set_routing_id(mId);
     168                 : 
     169                 : 
     170                 : 
     171               0 :     if (mozilla::ipc::LoggingEnabled()) {
     172               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     173                 :     }
     174               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_SetCacheTokenCachedCharset__ID), (&(mState)))))) {
     175               0 :         NS_WARNING("bad state transition!");
     176                 :     }
     177                 : 
     178               0 :     bool __sendok = (mChannel)->Send(__msg);
     179               0 :     return __sendok;
     180                 : }
     181                 : 
     182                 : bool
     183               0 : PHttpChannelChild::SendUpdateAssociatedContentSecurity(
     184                 :         const PRInt32& high,
     185                 :         const PRInt32& low,
     186                 :         const PRInt32& broken,
     187                 :         const PRInt32& no)
     188                 : {
     189               0 :     PHttpChannel::Msg_UpdateAssociatedContentSecurity* __msg = new PHttpChannel::Msg_UpdateAssociatedContentSecurity();
     190                 : 
     191               0 :     Write(high, __msg);
     192               0 :     Write(low, __msg);
     193               0 :     Write(broken, __msg);
     194               0 :     Write(no, __msg);
     195                 : 
     196               0 :     (__msg)->set_routing_id(mId);
     197                 : 
     198                 : 
     199                 : 
     200               0 :     if (mozilla::ipc::LoggingEnabled()) {
     201               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     202                 :     }
     203               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_UpdateAssociatedContentSecurity__ID), (&(mState)))))) {
     204               0 :         NS_WARNING("bad state transition!");
     205                 :     }
     206                 : 
     207               0 :     bool __sendok = (mChannel)->Send(__msg);
     208               0 :     return __sendok;
     209                 : }
     210                 : 
     211                 : bool
     212               0 : PHttpChannelChild::SendSuspend()
     213                 : {
     214               0 :     PHttpChannel::Msg_Suspend* __msg = new PHttpChannel::Msg_Suspend();
     215                 : 
     216                 : 
     217               0 :     (__msg)->set_routing_id(mId);
     218                 : 
     219                 : 
     220                 : 
     221               0 :     if (mozilla::ipc::LoggingEnabled()) {
     222               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     223                 :     }
     224               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_Suspend__ID), (&(mState)))))) {
     225               0 :         NS_WARNING("bad state transition!");
     226                 :     }
     227                 : 
     228               0 :     bool __sendok = (mChannel)->Send(__msg);
     229               0 :     return __sendok;
     230                 : }
     231                 : 
     232                 : bool
     233               0 : PHttpChannelChild::SendResume()
     234                 : {
     235               0 :     PHttpChannel::Msg_Resume* __msg = new PHttpChannel::Msg_Resume();
     236                 : 
     237                 : 
     238               0 :     (__msg)->set_routing_id(mId);
     239                 : 
     240                 : 
     241                 : 
     242               0 :     if (mozilla::ipc::LoggingEnabled()) {
     243               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     244                 :     }
     245               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_Resume__ID), (&(mState)))))) {
     246               0 :         NS_WARNING("bad state transition!");
     247                 :     }
     248                 : 
     249               0 :     bool __sendok = (mChannel)->Send(__msg);
     250               0 :     return __sendok;
     251                 : }
     252                 : 
     253                 : bool
     254               0 : PHttpChannelChild::SendCancel(const nsresult& status)
     255                 : {
     256               0 :     PHttpChannel::Msg_Cancel* __msg = new PHttpChannel::Msg_Cancel();
     257                 : 
     258               0 :     Write(status, __msg);
     259                 : 
     260               0 :     (__msg)->set_routing_id(mId);
     261                 : 
     262                 : 
     263                 : 
     264               0 :     if (mozilla::ipc::LoggingEnabled()) {
     265               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     266                 :     }
     267               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_Cancel__ID), (&(mState)))))) {
     268               0 :         NS_WARNING("bad state transition!");
     269                 :     }
     270                 : 
     271               0 :     bool __sendok = (mChannel)->Send(__msg);
     272               0 :     return __sendok;
     273                 : }
     274                 : 
     275                 : bool
     276               0 : PHttpChannelChild::SendRedirect2Verify(
     277                 :         const nsresult& result,
     278                 :         const RequestHeaderTuples& changedHeaders)
     279                 : {
     280               0 :     PHttpChannel::Msg_Redirect2Verify* __msg = new PHttpChannel::Msg_Redirect2Verify();
     281                 : 
     282               0 :     Write(result, __msg);
     283               0 :     Write(changedHeaders, __msg);
     284                 : 
     285               0 :     (__msg)->set_routing_id(mId);
     286                 : 
     287                 : 
     288                 : 
     289               0 :     if (mozilla::ipc::LoggingEnabled()) {
     290               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     291                 :     }
     292               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_Redirect2Verify__ID), (&(mState)))))) {
     293               0 :         NS_WARNING("bad state transition!");
     294                 :     }
     295                 : 
     296               0 :     bool __sendok = (mChannel)->Send(__msg);
     297               0 :     return __sendok;
     298                 : }
     299                 : 
     300                 : bool
     301               0 : PHttpChannelChild::SendDocumentChannelCleanup()
     302                 : {
     303               0 :     PHttpChannel::Msg_DocumentChannelCleanup* __msg = new PHttpChannel::Msg_DocumentChannelCleanup();
     304                 : 
     305                 : 
     306               0 :     (__msg)->set_routing_id(mId);
     307                 : 
     308                 : 
     309                 : 
     310               0 :     if (mozilla::ipc::LoggingEnabled()) {
     311               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     312                 :     }
     313               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_DocumentChannelCleanup__ID), (&(mState)))))) {
     314               0 :         NS_WARNING("bad state transition!");
     315                 :     }
     316                 : 
     317               0 :     bool __sendok = (mChannel)->Send(__msg);
     318               0 :     return __sendok;
     319                 : }
     320                 : 
     321                 : bool
     322               0 : PHttpChannelChild::SendMarkOfflineCacheEntryAsForeign()
     323                 : {
     324               0 :     PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign* __msg = new PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign();
     325                 : 
     326                 : 
     327               0 :     (__msg)->set_routing_id(mId);
     328                 : 
     329                 : 
     330                 : 
     331               0 :     if (mozilla::ipc::LoggingEnabled()) {
     332               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     333                 :     }
     334               0 :     if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Recv, PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign__ID), (&(mState)))))) {
     335               0 :         NS_WARNING("bad state transition!");
     336                 :     }
     337                 : 
     338               0 :     bool __sendok = (mChannel)->Send(__msg);
     339               0 :     return __sendok;
     340                 : }
     341                 : 
     342                 : bool
     343               0 : PHttpChannelChild::Send__delete__(PHttpChannelChild* actor)
     344                 : {
     345               0 :     if ((!(actor))) {
     346               0 :         return false;
     347                 :     }
     348                 : 
     349               0 :     if ((!(actor))) {
     350               0 :         return false;
     351                 :     }
     352                 : 
     353               0 :     PHttpChannel::Msg___delete__* __msg = new PHttpChannel::Msg___delete__();
     354                 : 
     355               0 :     (actor)->Write(actor, __msg, false);
     356                 : 
     357               0 :     (__msg)->set_routing_id((actor)->mId);
     358                 : 
     359                 : 
     360               0 :     if (mozilla::ipc::LoggingEnabled()) {
     361               0 :         (__msg)->Log("[PHttpChannelChild] Sending ", stderr);
     362                 :     }
     363               0 :     if ((!(PHttpChannel::Transition((actor)->mState, Trigger(Trigger::Recv, PHttpChannel::Msg___delete____ID), (&((actor)->mState)))))) {
     364               0 :         NS_WARNING("bad state transition!");
     365                 :     }
     366                 : 
     367               0 :     bool __sendok = ((actor)->mChannel)->Send(__msg);
     368                 : 
     369               0 :     (actor)->DestroySubtree(Deletion);
     370               0 :     (actor)->DeallocSubtree();
     371               0 :     ((actor)->mManager)->RemoveManagee(PHttpChannelMsgStart, actor);
     372               0 :     return __sendok;
     373                 : }
     374                 : 
     375                 : int32
     376               0 : PHttpChannelChild::Register(ChannelListener* aRouted)
     377                 : {
     378               0 :     return (mManager)->Register(aRouted);
     379                 : }
     380                 : 
     381                 : int32
     382               0 : PHttpChannelChild::RegisterID(
     383                 :         ChannelListener* aRouted,
     384                 :         int32 aId)
     385                 : {
     386               0 :     return (mManager)->RegisterID(aRouted, aId);
     387                 : }
     388                 : 
     389                 : ChannelListener*
     390               0 : PHttpChannelChild::Lookup(int32 aId)
     391                 : {
     392               0 :     return (mManager)->Lookup(aId);
     393                 : }
     394                 : 
     395                 : void
     396               0 : PHttpChannelChild::Unregister(int32 aId)
     397                 : {
     398               0 :     return (mManager)->Unregister(aId);
     399                 : }
     400                 : 
     401                 : void
     402               0 : PHttpChannelChild::RemoveManagee(
     403                 :         int32 aProtocolId,
     404                 :         ChannelListener* aListener)
     405                 : {
     406               0 :     NS_RUNTIMEABORT("unreached");
     407                 :     return;
     408                 : }
     409                 : 
     410                 : Shmem::SharedMemory*
     411               0 : PHttpChannelChild::CreateSharedMemory(
     412                 :         size_t aSize,
     413                 :         Shmem::SharedMemory::SharedMemoryType type,
     414                 :         bool unsafe,
     415                 :         Shmem::id_t* aId)
     416                 : {
     417               0 :     return (mManager)->CreateSharedMemory(aSize, type, unsafe, aId);
     418                 : }
     419                 : 
     420                 : bool
     421               0 : PHttpChannelChild::AdoptSharedMemory(
     422                 :         Shmem::SharedMemory* segment,
     423                 :         Shmem::id_t* aId)
     424                 : {
     425               0 :     return (mManager)->AdoptSharedMemory(segment, aId);
     426                 : }
     427                 : 
     428                 : Shmem::SharedMemory*
     429               0 : PHttpChannelChild::LookupSharedMemory(Shmem::id_t aId)
     430                 : {
     431               0 :     return (mManager)->LookupSharedMemory(aId);
     432                 : }
     433                 : 
     434                 : bool
     435               0 : PHttpChannelChild::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
     436                 : {
     437               0 :     return (mManager)->IsTrackingSharedMemory(segment);
     438                 : }
     439                 : 
     440                 : bool
     441               0 : PHttpChannelChild::DestroySharedMemory(Shmem& aShmem)
     442                 : {
     443               0 :     return (mManager)->DestroySharedMemory(aShmem);
     444                 : }
     445                 : 
     446                 : ProcessHandle
     447               0 : PHttpChannelChild::OtherProcess() const
     448                 : {
     449               0 :     return (mManager)->OtherProcess();
     450                 : }
     451                 : 
     452                 : AsyncChannel*
     453               0 : PHttpChannelChild::GetIPCChannel()
     454                 : {
     455               0 :     return mChannel;
     456                 : }
     457                 : 
     458                 : PHttpChannelChild::Result
     459               0 : PHttpChannelChild::OnMessageReceived(const Message& __msg)
     460                 : {
     461               0 :     switch ((__msg).type()) {
     462                 :     case PHttpChannel::Reply___delete____ID:
     463                 :         {
     464               0 :             return MsgProcessed;
     465                 :         }
     466                 :     case PHttpChannel::Msg_OnStartRequest__ID:
     467                 :         {
     468               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_OnStartRequest");
     469               0 :             if (mozilla::ipc::LoggingEnabled()) {
     470               0 :                 (static_cast<const PHttpChannel::Msg_OnStartRequest*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     471                 :             }
     472                 : 
     473               0 :             void* __iter = 0;
     474               0 :             nsHttpResponseHead responseHead;
     475                 :             bool useResponseHead;
     476               0 :             nsHttpHeaderArray requestHeaders;
     477                 :             bool isFromCache;
     478                 :             bool cacheEntryAvailable;
     479                 :             PRUint32 cacheExpirationTime;
     480               0 :             nsCString cachedCharset;
     481               0 :             nsCString securityInfoSerialization;
     482                 :             PRNetAddr selfAddr;
     483                 :             PRNetAddr peerAddr;
     484                 : 
     485               0 :             if ((!(Read((&(responseHead)), (&(__msg)), (&(__iter)))))) {
     486               0 :                 FatalError("error deserializing (better message TODO)");
     487               0 :                 return MsgValueError;
     488                 :             }
     489               0 :             if ((!(Read((&(useResponseHead)), (&(__msg)), (&(__iter)))))) {
     490               0 :                 FatalError("error deserializing (better message TODO)");
     491               0 :                 return MsgValueError;
     492                 :             }
     493               0 :             if ((!(Read((&(requestHeaders)), (&(__msg)), (&(__iter)))))) {
     494               0 :                 FatalError("error deserializing (better message TODO)");
     495               0 :                 return MsgValueError;
     496                 :             }
     497               0 :             if ((!(Read((&(isFromCache)), (&(__msg)), (&(__iter)))))) {
     498               0 :                 FatalError("error deserializing (better message TODO)");
     499               0 :                 return MsgValueError;
     500                 :             }
     501               0 :             if ((!(Read((&(cacheEntryAvailable)), (&(__msg)), (&(__iter)))))) {
     502               0 :                 FatalError("error deserializing (better message TODO)");
     503               0 :                 return MsgValueError;
     504                 :             }
     505               0 :             if ((!(Read((&(cacheExpirationTime)), (&(__msg)), (&(__iter)))))) {
     506               0 :                 FatalError("error deserializing (better message TODO)");
     507               0 :                 return MsgValueError;
     508                 :             }
     509               0 :             if ((!(Read((&(cachedCharset)), (&(__msg)), (&(__iter)))))) {
     510               0 :                 FatalError("error deserializing (better message TODO)");
     511               0 :                 return MsgValueError;
     512                 :             }
     513               0 :             if ((!(Read((&(securityInfoSerialization)), (&(__msg)), (&(__iter)))))) {
     514               0 :                 FatalError("error deserializing (better message TODO)");
     515               0 :                 return MsgValueError;
     516                 :             }
     517               0 :             if ((!(Read((&(selfAddr)), (&(__msg)), (&(__iter)))))) {
     518               0 :                 FatalError("error deserializing (better message TODO)");
     519               0 :                 return MsgValueError;
     520                 :             }
     521               0 :             if ((!(Read((&(peerAddr)), (&(__msg)), (&(__iter)))))) {
     522               0 :                 FatalError("error deserializing (better message TODO)");
     523               0 :                 return MsgValueError;
     524                 :             }
     525               0 :             (__msg).EndRead(__iter);
     526               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_OnStartRequest__ID), (&(mState)))))) {
     527               0 :                 NS_WARNING("bad state transition!");
     528                 :             }
     529               0 :             if ((!(RecvOnStartRequest(responseHead, useResponseHead, requestHeaders, isFromCache, cacheEntryAvailable, cacheExpirationTime, cachedCharset, securityInfoSerialization, selfAddr, peerAddr)))) {
     530               0 :                 return MsgProcessingError;
     531                 :             }
     532                 : 
     533               0 :             return MsgProcessed;
     534                 :         }
     535                 :     case PHttpChannel::Msg_OnTransportAndData__ID:
     536                 :         {
     537               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_OnTransportAndData");
     538               0 :             if (mozilla::ipc::LoggingEnabled()) {
     539               0 :                 (static_cast<const PHttpChannel::Msg_OnTransportAndData*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     540                 :             }
     541                 : 
     542               0 :             void* __iter = 0;
     543                 :             nsresult status;
     544                 :             PRUint64 progress;
     545                 :             PRUint64 progressMax;
     546               0 :             nsCString data;
     547                 :             PRUint32 offset;
     548                 :             PRUint32 count;
     549                 : 
     550               0 :             if ((!(Read((&(status)), (&(__msg)), (&(__iter)))))) {
     551               0 :                 FatalError("error deserializing (better message TODO)");
     552               0 :                 return MsgValueError;
     553                 :             }
     554               0 :             if ((!(Read((&(progress)), (&(__msg)), (&(__iter)))))) {
     555               0 :                 FatalError("error deserializing (better message TODO)");
     556               0 :                 return MsgValueError;
     557                 :             }
     558               0 :             if ((!(Read((&(progressMax)), (&(__msg)), (&(__iter)))))) {
     559               0 :                 FatalError("error deserializing (better message TODO)");
     560               0 :                 return MsgValueError;
     561                 :             }
     562               0 :             if ((!(Read((&(data)), (&(__msg)), (&(__iter)))))) {
     563               0 :                 FatalError("error deserializing (better message TODO)");
     564               0 :                 return MsgValueError;
     565                 :             }
     566               0 :             if ((!(Read((&(offset)), (&(__msg)), (&(__iter)))))) {
     567               0 :                 FatalError("error deserializing (better message TODO)");
     568               0 :                 return MsgValueError;
     569                 :             }
     570               0 :             if ((!(Read((&(count)), (&(__msg)), (&(__iter)))))) {
     571               0 :                 FatalError("error deserializing (better message TODO)");
     572               0 :                 return MsgValueError;
     573                 :             }
     574               0 :             (__msg).EndRead(__iter);
     575               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_OnTransportAndData__ID), (&(mState)))))) {
     576               0 :                 NS_WARNING("bad state transition!");
     577                 :             }
     578               0 :             if ((!(RecvOnTransportAndData(status, progress, progressMax, data, offset, count)))) {
     579               0 :                 return MsgProcessingError;
     580                 :             }
     581                 : 
     582               0 :             return MsgProcessed;
     583                 :         }
     584                 :     case PHttpChannel::Msg_OnStopRequest__ID:
     585                 :         {
     586               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_OnStopRequest");
     587               0 :             if (mozilla::ipc::LoggingEnabled()) {
     588               0 :                 (static_cast<const PHttpChannel::Msg_OnStopRequest*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     589                 :             }
     590                 : 
     591               0 :             void* __iter = 0;
     592                 :             nsresult statusCode;
     593                 : 
     594               0 :             if ((!(Read((&(statusCode)), (&(__msg)), (&(__iter)))))) {
     595               0 :                 FatalError("error deserializing (better message TODO)");
     596               0 :                 return MsgValueError;
     597                 :             }
     598               0 :             (__msg).EndRead(__iter);
     599               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_OnStopRequest__ID), (&(mState)))))) {
     600               0 :                 NS_WARNING("bad state transition!");
     601                 :             }
     602               0 :             if ((!(RecvOnStopRequest(statusCode)))) {
     603               0 :                 return MsgProcessingError;
     604                 :             }
     605                 : 
     606               0 :             return MsgProcessed;
     607                 :         }
     608                 :     case PHttpChannel::Msg_OnProgress__ID:
     609                 :         {
     610               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_OnProgress");
     611               0 :             if (mozilla::ipc::LoggingEnabled()) {
     612               0 :                 (static_cast<const PHttpChannel::Msg_OnProgress*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     613                 :             }
     614                 : 
     615               0 :             void* __iter = 0;
     616                 :             PRUint64 progress;
     617                 :             PRUint64 progressMax;
     618                 : 
     619               0 :             if ((!(Read((&(progress)), (&(__msg)), (&(__iter)))))) {
     620               0 :                 FatalError("error deserializing (better message TODO)");
     621               0 :                 return MsgValueError;
     622                 :             }
     623               0 :             if ((!(Read((&(progressMax)), (&(__msg)), (&(__iter)))))) {
     624               0 :                 FatalError("error deserializing (better message TODO)");
     625               0 :                 return MsgValueError;
     626                 :             }
     627               0 :             (__msg).EndRead(__iter);
     628               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_OnProgress__ID), (&(mState)))))) {
     629               0 :                 NS_WARNING("bad state transition!");
     630                 :             }
     631               0 :             if ((!(RecvOnProgress(progress, progressMax)))) {
     632               0 :                 return MsgProcessingError;
     633                 :             }
     634                 : 
     635               0 :             return MsgProcessed;
     636                 :         }
     637                 :     case PHttpChannel::Msg_OnStatus__ID:
     638                 :         {
     639               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_OnStatus");
     640               0 :             if (mozilla::ipc::LoggingEnabled()) {
     641               0 :                 (static_cast<const PHttpChannel::Msg_OnStatus*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     642                 :             }
     643                 : 
     644               0 :             void* __iter = 0;
     645                 :             nsresult status;
     646                 : 
     647               0 :             if ((!(Read((&(status)), (&(__msg)), (&(__iter)))))) {
     648               0 :                 FatalError("error deserializing (better message TODO)");
     649               0 :                 return MsgValueError;
     650                 :             }
     651               0 :             (__msg).EndRead(__iter);
     652               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_OnStatus__ID), (&(mState)))))) {
     653               0 :                 NS_WARNING("bad state transition!");
     654                 :             }
     655               0 :             if ((!(RecvOnStatus(status)))) {
     656               0 :                 return MsgProcessingError;
     657                 :             }
     658                 : 
     659               0 :             return MsgProcessed;
     660                 :         }
     661                 :     case PHttpChannel::Msg_FailedAsyncOpen__ID:
     662                 :         {
     663               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_FailedAsyncOpen");
     664               0 :             if (mozilla::ipc::LoggingEnabled()) {
     665               0 :                 (static_cast<const PHttpChannel::Msg_FailedAsyncOpen*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     666                 :             }
     667                 : 
     668               0 :             void* __iter = 0;
     669                 :             nsresult status;
     670                 : 
     671               0 :             if ((!(Read((&(status)), (&(__msg)), (&(__iter)))))) {
     672               0 :                 FatalError("error deserializing (better message TODO)");
     673               0 :                 return MsgValueError;
     674                 :             }
     675               0 :             (__msg).EndRead(__iter);
     676               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_FailedAsyncOpen__ID), (&(mState)))))) {
     677               0 :                 NS_WARNING("bad state transition!");
     678                 :             }
     679               0 :             if ((!(RecvFailedAsyncOpen(status)))) {
     680               0 :                 return MsgProcessingError;
     681                 :             }
     682                 : 
     683               0 :             return MsgProcessed;
     684                 :         }
     685                 :     case PHttpChannel::Msg_Redirect1Begin__ID:
     686                 :         {
     687               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_Redirect1Begin");
     688               0 :             if (mozilla::ipc::LoggingEnabled()) {
     689               0 :                 (static_cast<const PHttpChannel::Msg_Redirect1Begin*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     690                 :             }
     691                 : 
     692               0 :             void* __iter = 0;
     693                 :             PRUint32 newChannelId;
     694               0 :             URI newUri;
     695                 :             PRUint32 redirectFlags;
     696               0 :             nsHttpResponseHead responseHead;
     697                 : 
     698               0 :             if ((!(Read((&(newChannelId)), (&(__msg)), (&(__iter)))))) {
     699               0 :                 FatalError("error deserializing (better message TODO)");
     700               0 :                 return MsgValueError;
     701                 :             }
     702               0 :             if ((!(Read((&(newUri)), (&(__msg)), (&(__iter)))))) {
     703               0 :                 FatalError("error deserializing (better message TODO)");
     704               0 :                 return MsgValueError;
     705                 :             }
     706               0 :             if ((!(Read((&(redirectFlags)), (&(__msg)), (&(__iter)))))) {
     707               0 :                 FatalError("error deserializing (better message TODO)");
     708               0 :                 return MsgValueError;
     709                 :             }
     710               0 :             if ((!(Read((&(responseHead)), (&(__msg)), (&(__iter)))))) {
     711               0 :                 FatalError("error deserializing (better message TODO)");
     712               0 :                 return MsgValueError;
     713                 :             }
     714               0 :             (__msg).EndRead(__iter);
     715               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_Redirect1Begin__ID), (&(mState)))))) {
     716               0 :                 NS_WARNING("bad state transition!");
     717                 :             }
     718               0 :             if ((!(RecvRedirect1Begin(newChannelId, newUri, redirectFlags, responseHead)))) {
     719               0 :                 return MsgProcessingError;
     720                 :             }
     721                 : 
     722               0 :             return MsgProcessed;
     723                 :         }
     724                 :     case PHttpChannel::Msg_Redirect3Complete__ID:
     725                 :         {
     726               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_Redirect3Complete");
     727               0 :             if (mozilla::ipc::LoggingEnabled()) {
     728               0 :                 (static_cast<const PHttpChannel::Msg_Redirect3Complete*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     729                 :             }
     730                 : 
     731               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_Redirect3Complete__ID), (&(mState)))))) {
     732               0 :                 NS_WARNING("bad state transition!");
     733                 :             }
     734               0 :             if ((!(RecvRedirect3Complete()))) {
     735               0 :                 return MsgProcessingError;
     736                 :             }
     737                 : 
     738               0 :             return MsgProcessed;
     739                 :         }
     740                 :     case PHttpChannel::Msg_AssociateApplicationCache__ID:
     741                 :         {
     742               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_AssociateApplicationCache");
     743               0 :             if (mozilla::ipc::LoggingEnabled()) {
     744               0 :                 (static_cast<const PHttpChannel::Msg_AssociateApplicationCache*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     745                 :             }
     746                 : 
     747               0 :             void* __iter = 0;
     748               0 :             nsCString groupID;
     749               0 :             nsCString clientID;
     750                 : 
     751               0 :             if ((!(Read((&(groupID)), (&(__msg)), (&(__iter)))))) {
     752               0 :                 FatalError("error deserializing (better message TODO)");
     753               0 :                 return MsgValueError;
     754                 :             }
     755               0 :             if ((!(Read((&(clientID)), (&(__msg)), (&(__iter)))))) {
     756               0 :                 FatalError("error deserializing (better message TODO)");
     757               0 :                 return MsgValueError;
     758                 :             }
     759               0 :             (__msg).EndRead(__iter);
     760               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_AssociateApplicationCache__ID), (&(mState)))))) {
     761               0 :                 NS_WARNING("bad state transition!");
     762                 :             }
     763               0 :             if ((!(RecvAssociateApplicationCache(groupID, clientID)))) {
     764               0 :                 return MsgProcessingError;
     765                 :             }
     766                 : 
     767               0 :             return MsgProcessed;
     768                 :         }
     769                 :     case PHttpChannel::Msg_DeleteSelf__ID:
     770                 :         {
     771               0 :             (const_cast<Message&>(__msg)).set_name("PHttpChannel::Msg_DeleteSelf");
     772               0 :             if (mozilla::ipc::LoggingEnabled()) {
     773               0 :                 (static_cast<const PHttpChannel::Msg_DeleteSelf*>((&(__msg))))->Log("[PHttpChannelChild] Received ", stderr);
     774                 :             }
     775                 : 
     776               0 :             if ((!(PHttpChannel::Transition(mState, Trigger(Trigger::Send, PHttpChannel::Msg_DeleteSelf__ID), (&(mState)))))) {
     777               0 :                 NS_WARNING("bad state transition!");
     778                 :             }
     779               0 :             if ((!(RecvDeleteSelf()))) {
     780               0 :                 return MsgProcessingError;
     781                 :             }
     782                 : 
     783               0 :             return MsgProcessed;
     784                 :         }
     785                 :     default:
     786                 :         {
     787               0 :             return MsgNotKnown;
     788                 :         }
     789                 :     }
     790                 : }
     791                 : 
     792                 : PHttpChannelChild::Result
     793               0 : PHttpChannelChild::OnMessageReceived(
     794                 :         const Message& __msg,
     795                 :         Message*& __reply)
     796                 : {
     797               0 :     return MsgNotKnown;
     798                 : }
     799                 : 
     800                 : PHttpChannelChild::Result
     801               0 : PHttpChannelChild::OnCallReceived(
     802                 :         const Message& __msg,
     803                 :         Message*& __reply)
     804                 : {
     805               0 :     return MsgNotKnown;
     806                 : }
     807                 : 
     808                 : void
     809               0 : PHttpChannelChild::OnProcessingError(Result code)
     810                 : {
     811               0 :     NS_RUNTIMEABORT("`OnProcessingError' called on non-toplevel actor");
     812               0 : }
     813                 : 
     814                 : bool
     815               0 : PHttpChannelChild::OnReplyTimeout()
     816                 : {
     817               0 :     NS_RUNTIMEABORT("`OnReplyTimeout' called on non-toplevel actor");
     818               0 :     return false;
     819                 : }
     820                 : 
     821                 : void
     822               0 : PHttpChannelChild::OnChannelClose()
     823                 : {
     824               0 :     NS_RUNTIMEABORT("`OnClose' called on non-toplevel actor");
     825               0 : }
     826                 : 
     827                 : void
     828               0 : PHttpChannelChild::OnChannelError()
     829                 : {
     830               0 :     NS_RUNTIMEABORT("`OnError' called on non-toplevel actor");
     831               0 : }
     832                 : 
     833                 : void
     834               0 : PHttpChannelChild::OnChannelConnected(int32 pid)
     835                 : {
     836               0 :     NS_RUNTIMEABORT("'OnConnected' called on non-toplevel actor");
     837               0 : }
     838                 : 
     839                 : bool
     840               0 : PHttpChannelChild::AllocShmem(
     841                 :         size_t aSize,
     842                 :         Shmem::SharedMemory::SharedMemoryType aType,
     843                 :         Shmem* aMem)
     844                 : {
     845                 :     Shmem::id_t aId;
     846               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
     847               0 :     if ((!(rawmem))) {
     848               0 :         return false;
     849                 :     }
     850                 : 
     851               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     852               0 :     return true;
     853                 : }
     854                 : 
     855                 : bool
     856               0 : PHttpChannelChild::AllocUnsafeShmem(
     857                 :         size_t aSize,
     858                 :         Shmem::SharedMemory::SharedMemoryType aType,
     859                 :         Shmem* aMem)
     860                 : {
     861                 :     Shmem::id_t aId;
     862               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
     863               0 :     if ((!(rawmem))) {
     864               0 :         return false;
     865                 :     }
     866                 : 
     867               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     868               0 :     return true;
     869                 : }
     870                 : 
     871                 : bool
     872               0 : PHttpChannelChild::AdoptShmem(
     873                 :         Shmem& aMem,
     874                 :         Shmem* aOutMem)
     875                 : {
     876               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     877               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
     878               0 :         NS_RUNTIMEABORT("bad Shmem");
     879                 :     }
     880                 : 
     881                 :     Shmem::id_t aId;
     882               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
     883               0 :         return false;
     884                 :     }
     885                 : 
     886               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
     887               0 :     return true;
     888                 : }
     889                 : 
     890                 : bool
     891               0 : PHttpChannelChild::DeallocShmem(Shmem& aMem)
     892                 : {
     893               0 :     bool ok = DestroySharedMemory(aMem);
     894               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     895               0 :     return ok;
     896                 : }
     897                 : 
     898                 : void
     899               0 : PHttpChannelChild::FatalError(const char* const msg) const
     900                 : {
     901                 :     // Virtual method to prevent inlining.
     902                 :     // This give us better error reporting.
     903                 :     // See bug 589371
     904                 : 
     905               0 :     NS_ERROR("IPDL error:");
     906               0 :     NS_ERROR(msg);
     907                 : 
     908               0 :     NS_RUNTIMEABORT("[PHttpChannelChild] abort()ing as a result");
     909               0 : }
     910                 : 
     911                 : void
     912               0 : PHttpChannelChild::DestroySubtree(ActorDestroyReason why)
     913                 : {
     914                 :     // Unregister from our manager.
     915               0 :     Unregister(mId);
     916               0 :     mId = 1;
     917                 : 
     918                 :     // Finally, destroy "us".
     919               0 :     ActorDestroy(why);
     920               0 : }
     921                 : 
     922                 : void
     923               0 : PHttpChannelChild::DeallocSubtree()
     924                 : {
     925               0 : }
     926                 : 
     927                 : void
     928               0 : PHttpChannelChild::Write(
     929                 :         PHttpChannelChild* __v,
     930                 :         Message* __msg,
     931                 :         bool __nullable)
     932                 : {
     933                 :     int32 id;
     934               0 :     if ((!(__v))) {
     935               0 :         if ((!(__nullable))) {
     936               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
     937                 :         }
     938               0 :         id = 0;
     939                 :     }
     940                 :     else {
     941               0 :         id = (__v)->mId;
     942               0 :         if ((1) == (id)) {
     943               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
     944                 :         }
     945                 :     }
     946                 : 
     947               0 :     Write(id, __msg);
     948               0 : }
     949                 : 
     950                 : bool
     951               0 : PHttpChannelChild::Read(
     952                 :         PHttpChannelChild** __v,
     953                 :         const Message* __msg,
     954                 :         void** __iter,
     955                 :         bool __nullable)
     956                 : {
     957                 :     int32 id;
     958               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
     959               0 :         return false;
     960                 :     }
     961               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
     962               0 :         return false;
     963                 :     }
     964                 : 
     965               0 :     if ((0) == (id)) {
     966               0 :         (*(__v)) = 0;
     967                 :     }
     968                 :     else {
     969               0 :         (*(__v)) = static_cast<PHttpChannelChild*>(Lookup(id));
     970               0 :         if ((!((*(__v))))) {
     971               0 :             return false;
     972                 :         }
     973                 :     }
     974               0 :     return true;
     975                 : }
     976                 : 
     977                 : 
     978                 : 
     979                 : } // namespace net
     980                 : } // namespace mozilla

Generated by: LCOV version 1.7