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

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-04-21 | 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