LCOV - app.info - objdir/ipc/ipdl/_ipdlheaders/mozilla/net/PHttpChannel.h

LCOV - code coverage report
| Current view: | directory - objdir/ipc/ipdl/_ipdlheaders/mozilla/net - PHttpChannel.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 264 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 88 | 0 | 0.0 %

           1                 : //
           2                 : // Automatically generated by ipdlc.
           3                 : // Edit at your own risk
           4                 : //
           5                 :
           6                 : #ifndef PHttpChannel_h
           7                 : #define PHttpChannel_h
           8                 :
           9                 : #include "mozilla/Attributes.h"
          10                 : #include "base/basictypes.h"
          11                 : #include "prtime.h"
          12                 : #include "nscore.h"
          13                 : #include "IPCMessageStart.h"
          14                 : #include "IPC/IPCMessageUtils.h"
          15                 : #include "nsAutoPtr.h"
          16                 : #include "nsStringGlue.h"
          17                 : #include "nsTArray.h"
          18                 : #include "nsIFile.h"
          19                 : #include "mozilla/ipc/ProtocolUtils.h"
          20                 : #include "mozilla/net/PHttpChannelParams.h"
          21                 : #include "mozilla/net/NeckoMessageUtils.h"
          22                 : #include "prio.h"
          23                 :
          24                 : //-----------------------------------------------------------------------------
          25                 : // Code common to PHttpChannelChild and PHttpChannelParent
          26                 : //
          27                 : namespace mozilla {
          28                 : namespace net {
          29                 : namespace PHttpChannel {
          30                 :
          31                 : enum State {
          32                 :     __Dead,
          33                 :     __Null,
          34                 :     __Error,
          35                 :     __Start = __Null
          36                 : };
          37                 :
          38                 : enum MessageType {
          39                 :     PHttpChannelStart = PHttpChannelMsgStart << 16,
          40                 :     PHttpChannelPreStart = (PHttpChannelMsgStart << 16) - 1,
          41                 :     Msg_AsyncOpen__ID,
          42                 :     Msg_ConnectChannel__ID,
          43                 :     Msg_SetPriority__ID,
          44                 :     Msg_SetCacheTokenCachedCharset__ID,
          45                 :     Msg_UpdateAssociatedContentSecurity__ID,
          46                 :     Msg_Suspend__ID,
          47                 :     Msg_Resume__ID,
          48                 :     Msg_Cancel__ID,
          49                 :     Msg_Redirect2Verify__ID,
          50                 :     Msg_DocumentChannelCleanup__ID,
          51                 :     Msg_MarkOfflineCacheEntryAsForeign__ID,
          52                 :     Msg___delete____ID,
          53                 :     Reply___delete____ID,
          54                 :     Msg_OnStartRequest__ID,
          55                 :     Msg_OnTransportAndData__ID,
          56                 :     Msg_OnStopRequest__ID,
          57                 :     Msg_OnProgress__ID,
          58                 :     Msg_OnStatus__ID,
          59                 :     Msg_FailedAsyncOpen__ID,
          60                 :     Msg_Redirect1Begin__ID,
          61                 :     Msg_Redirect3Complete__ID,
          62                 :     Msg_AssociateApplicationCache__ID,
          63                 :     Msg_DeleteSelf__ID,
          64                 :     PHttpChannelEnd
          65                 : };
          66                 :
          67                 : bool
          68                 : Transition(
          69                 :         State from,
          70                 :         mozilla::ipc::Trigger trigger,
          71                 :         State* next);
          72                 :
          73                 : class Msg_AsyncOpen :
          74                 :     public IPC::Message
          75               0 : {
          76                 : private:
          77                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
          78                 :     typedef mozilla::ipc::Shmem Shmem;
          79                 :     typedef IPC::URI URI;
          80                 :     typedef IPC::InputStream InputStream;
          81                 :
          82                 : public:
          83                 :     enum {
          84                 :         ID = Msg_AsyncOpen__ID
          85                 :     };
          86               0 :     Msg_AsyncOpen() :
          87               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_AsyncOpen")
          88                 :     {
          89               0 :     }
          90                 :
          91                 :     void
          92               0 :     Log(
          93                 :             const std::string& __pfx,
          94                 :             FILE* __outf) const
          95                 :     {
          96               0 :         std::string __logmsg;
          97               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
          98               0 :         (__logmsg).append(__pfx);
          99               0 :         (__logmsg).append("Msg_AsyncOpen(");
         100                 :
         101               0 :         (__logmsg).append("[TODO])\n");
         102               0 :         fputs((__logmsg).c_str(), __outf);
         103               0 :     }
         104                 : };
         105                 :
         106                 : class Msg_ConnectChannel :
         107                 :     public IPC::Message
         108               0 : {
         109                 : private:
         110                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         111                 :     typedef mozilla::ipc::Shmem Shmem;
         112                 :     typedef IPC::URI URI;
         113                 :     typedef IPC::InputStream InputStream;
         114                 :
         115                 : public:
         116                 :     enum {
         117                 :         ID = Msg_ConnectChannel__ID
         118                 :     };
         119               0 :     Msg_ConnectChannel() :
         120               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_ConnectChannel")
         121                 :     {
         122               0 :     }
         123                 :
         124                 :     void
         125               0 :     Log(
         126                 :             const std::string& __pfx,
         127                 :             FILE* __outf) const
         128                 :     {
         129               0 :         std::string __logmsg;
         130               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         131               0 :         (__logmsg).append(__pfx);
         132               0 :         (__logmsg).append("Msg_ConnectChannel(");
         133                 :
         134               0 :         (__logmsg).append("[TODO])\n");
         135               0 :         fputs((__logmsg).c_str(), __outf);
         136               0 :     }
         137                 : };
         138                 :
         139                 : class Msg_SetPriority :
         140                 :     public IPC::Message
         141               0 : {
         142                 : private:
         143                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         144                 :     typedef mozilla::ipc::Shmem Shmem;
         145                 :     typedef IPC::URI URI;
         146                 :     typedef IPC::InputStream InputStream;
         147                 :
         148                 : public:
         149                 :     enum {
         150                 :         ID = Msg_SetPriority__ID
         151                 :     };
         152               0 :     Msg_SetPriority() :
         153               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_SetPriority")
         154                 :     {
         155               0 :     }
         156                 :
         157                 :     void
         158               0 :     Log(
         159                 :             const std::string& __pfx,
         160                 :             FILE* __outf) const
         161                 :     {
         162               0 :         std::string __logmsg;
         163               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         164               0 :         (__logmsg).append(__pfx);
         165               0 :         (__logmsg).append("Msg_SetPriority(");
         166                 :
         167               0 :         (__logmsg).append("[TODO])\n");
         168               0 :         fputs((__logmsg).c_str(), __outf);
         169               0 :     }
         170                 : };
         171                 :
         172                 : class Msg_SetCacheTokenCachedCharset :
         173                 :     public IPC::Message
         174               0 : {
         175                 : private:
         176                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         177                 :     typedef mozilla::ipc::Shmem Shmem;
         178                 :     typedef IPC::URI URI;
         179                 :     typedef IPC::InputStream InputStream;
         180                 :
         181                 : public:
         182                 :     enum {
         183                 :         ID = Msg_SetCacheTokenCachedCharset__ID
         184                 :     };
         185               0 :     Msg_SetCacheTokenCachedCharset() :
         186               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_SetCacheTokenCachedCharset")
         187                 :     {
         188               0 :     }
         189                 :
         190                 :     void
         191               0 :     Log(
         192                 :             const std::string& __pfx,
         193                 :             FILE* __outf) const
         194                 :     {
         195               0 :         std::string __logmsg;
         196               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         197               0 :         (__logmsg).append(__pfx);
         198               0 :         (__logmsg).append("Msg_SetCacheTokenCachedCharset(");
         199                 :
         200               0 :         (__logmsg).append("[TODO])\n");
         201               0 :         fputs((__logmsg).c_str(), __outf);
         202               0 :     }
         203                 : };
         204                 :
         205                 : class Msg_UpdateAssociatedContentSecurity :
         206                 :     public IPC::Message
         207               0 : {
         208                 : private:
         209                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         210                 :     typedef mozilla::ipc::Shmem Shmem;
         211                 :     typedef IPC::URI URI;
         212                 :     typedef IPC::InputStream InputStream;
         213                 :
         214                 : public:
         215                 :     enum {
         216                 :         ID = Msg_UpdateAssociatedContentSecurity__ID
         217                 :     };
         218               0 :     Msg_UpdateAssociatedContentSecurity() :
         219               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_UpdateAssociatedContentSecurity")
         220                 :     {
         221               0 :     }
         222                 :
         223                 :     void
         224               0 :     Log(
         225                 :             const std::string& __pfx,
         226                 :             FILE* __outf) const
         227                 :     {
         228               0 :         std::string __logmsg;
         229               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         230               0 :         (__logmsg).append(__pfx);
         231               0 :         (__logmsg).append("Msg_UpdateAssociatedContentSecurity(");
         232                 :
         233               0 :         (__logmsg).append("[TODO])\n");
         234               0 :         fputs((__logmsg).c_str(), __outf);
         235               0 :     }
         236                 : };
         237                 :
         238                 : class Msg_Suspend :
         239                 :     public IPC::Message
         240               0 : {
         241                 : private:
         242                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         243                 :     typedef mozilla::ipc::Shmem Shmem;
         244                 :     typedef IPC::URI URI;
         245                 :     typedef IPC::InputStream InputStream;
         246                 :
         247                 : public:
         248                 :     enum {
         249                 :         ID = Msg_Suspend__ID
         250                 :     };
         251               0 :     Msg_Suspend() :
         252               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Suspend")
         253                 :     {
         254               0 :     }
         255                 :
         256                 :     void
         257               0 :     Log(
         258                 :             const std::string& __pfx,
         259                 :             FILE* __outf) const
         260                 :     {
         261               0 :         std::string __logmsg;
         262               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         263               0 :         (__logmsg).append(__pfx);
         264               0 :         (__logmsg).append("Msg_Suspend(");
         265                 :
         266               0 :         (__logmsg).append("[TODO])\n");
         267               0 :         fputs((__logmsg).c_str(), __outf);
         268               0 :     }
         269                 : };
         270                 :
         271                 : class Msg_Resume :
         272                 :     public IPC::Message
         273               0 : {
         274                 : private:
         275                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         276                 :     typedef mozilla::ipc::Shmem Shmem;
         277                 :     typedef IPC::URI URI;
         278                 :     typedef IPC::InputStream InputStream;
         279                 :
         280                 : public:
         281                 :     enum {
         282                 :         ID = Msg_Resume__ID
         283                 :     };
         284               0 :     Msg_Resume() :
         285               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Resume")
         286                 :     {
         287               0 :     }
         288                 :
         289                 :     void
         290               0 :     Log(
         291                 :             const std::string& __pfx,
         292                 :             FILE* __outf) const
         293                 :     {
         294               0 :         std::string __logmsg;
         295               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         296               0 :         (__logmsg).append(__pfx);
         297               0 :         (__logmsg).append("Msg_Resume(");
         298                 :
         299               0 :         (__logmsg).append("[TODO])\n");
         300               0 :         fputs((__logmsg).c_str(), __outf);
         301               0 :     }
         302                 : };
         303                 :
         304                 : class Msg_Cancel :
         305                 :     public IPC::Message
         306               0 : {
         307                 : private:
         308                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         309                 :     typedef mozilla::ipc::Shmem Shmem;
         310                 :     typedef IPC::URI URI;
         311                 :     typedef IPC::InputStream InputStream;
         312                 :
         313                 : public:
         314                 :     enum {
         315                 :         ID = Msg_Cancel__ID
         316                 :     };
         317               0 :     Msg_Cancel() :
         318               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Cancel")
         319                 :     {
         320               0 :     }
         321                 :
         322                 :     void
         323               0 :     Log(
         324                 :             const std::string& __pfx,
         325                 :             FILE* __outf) const
         326                 :     {
         327               0 :         std::string __logmsg;
         328               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         329               0 :         (__logmsg).append(__pfx);
         330               0 :         (__logmsg).append("Msg_Cancel(");
         331                 :
         332               0 :         (__logmsg).append("[TODO])\n");
         333               0 :         fputs((__logmsg).c_str(), __outf);
         334               0 :     }
         335                 : };
         336                 :
         337                 : class Msg_Redirect2Verify :
         338                 :     public IPC::Message
         339               0 : {
         340                 : private:
         341                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         342                 :     typedef mozilla::ipc::Shmem Shmem;
         343                 :     typedef IPC::URI URI;
         344                 :     typedef IPC::InputStream InputStream;
         345                 :
         346                 : public:
         347                 :     enum {
         348                 :         ID = Msg_Redirect2Verify__ID
         349                 :     };
         350               0 :     Msg_Redirect2Verify() :
         351               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Redirect2Verify")
         352                 :     {
         353               0 :     }
         354                 :
         355                 :     void
         356               0 :     Log(
         357                 :             const std::string& __pfx,
         358                 :             FILE* __outf) const
         359                 :     {
         360               0 :         std::string __logmsg;
         361               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         362               0 :         (__logmsg).append(__pfx);
         363               0 :         (__logmsg).append("Msg_Redirect2Verify(");
         364                 :
         365               0 :         (__logmsg).append("[TODO])\n");
         366               0 :         fputs((__logmsg).c_str(), __outf);
         367               0 :     }
         368                 : };
         369                 :
         370                 : class Msg_DocumentChannelCleanup :
         371                 :     public IPC::Message
         372               0 : {
         373                 : private:
         374                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         375                 :     typedef mozilla::ipc::Shmem Shmem;
         376                 :     typedef IPC::URI URI;
         377                 :     typedef IPC::InputStream InputStream;
         378                 :
         379                 : public:
         380                 :     enum {
         381                 :         ID = Msg_DocumentChannelCleanup__ID
         382                 :     };
         383               0 :     Msg_DocumentChannelCleanup() :
         384               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_DocumentChannelCleanup")
         385                 :     {
         386               0 :     }
         387                 :
         388                 :     void
         389               0 :     Log(
         390                 :             const std::string& __pfx,
         391                 :             FILE* __outf) const
         392                 :     {
         393               0 :         std::string __logmsg;
         394               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         395               0 :         (__logmsg).append(__pfx);
         396               0 :         (__logmsg).append("Msg_DocumentChannelCleanup(");
         397                 :
         398               0 :         (__logmsg).append("[TODO])\n");
         399               0 :         fputs((__logmsg).c_str(), __outf);
         400               0 :     }
         401                 : };
         402                 :
         403                 : class Msg_MarkOfflineCacheEntryAsForeign :
         404                 :     public IPC::Message
         405               0 : {
         406                 : private:
         407                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         408                 :     typedef mozilla::ipc::Shmem Shmem;
         409                 :     typedef IPC::URI URI;
         410                 :     typedef IPC::InputStream InputStream;
         411                 :
         412                 : public:
         413                 :     enum {
         414                 :         ID = Msg_MarkOfflineCacheEntryAsForeign__ID
         415                 :     };
         416               0 :     Msg_MarkOfflineCacheEntryAsForeign() :
         417               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_MarkOfflineCacheEntryAsForeign")
         418                 :     {
         419               0 :     }
         420                 :
         421                 :     void
         422               0 :     Log(
         423                 :             const std::string& __pfx,
         424                 :             FILE* __outf) const
         425                 :     {
         426               0 :         std::string __logmsg;
         427               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         428               0 :         (__logmsg).append(__pfx);
         429               0 :         (__logmsg).append("Msg_MarkOfflineCacheEntryAsForeign(");
         430                 :
         431               0 :         (__logmsg).append("[TODO])\n");
         432               0 :         fputs((__logmsg).c_str(), __outf);
         433               0 :     }
         434                 : };
         435                 :
         436                 : class Msg___delete__ :
         437                 :     public IPC::Message
         438               0 : {
         439                 : private:
         440                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         441                 :     typedef mozilla::ipc::Shmem Shmem;
         442                 :     typedef IPC::URI URI;
         443                 :     typedef IPC::InputStream InputStream;
         444                 :
         445                 : public:
         446                 :     enum {
         447                 :         ID = Msg___delete____ID
         448                 :     };
         449               0 :     Msg___delete__() :
         450               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg___delete__")
         451                 :     {
         452               0 :     }
         453                 :
         454                 :     void
         455               0 :     Log(
         456                 :             const std::string& __pfx,
         457                 :             FILE* __outf) const
         458                 :     {
         459               0 :         std::string __logmsg;
         460               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         461               0 :         (__logmsg).append(__pfx);
         462               0 :         (__logmsg).append("Msg___delete__(");
         463                 :
         464               0 :         (__logmsg).append("[TODO])\n");
         465               0 :         fputs((__logmsg).c_str(), __outf);
         466               0 :     }
         467                 : };
         468                 :
         469                 : class Reply___delete__ :
         470                 :     public IPC::Message
         471                 : {
         472                 : private:
         473                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         474                 :     typedef mozilla::ipc::Shmem Shmem;
         475                 :     typedef IPC::URI URI;
         476                 :     typedef IPC::InputStream InputStream;
         477                 :
         478                 : public:
         479                 :     enum {
         480                 :         ID = Reply___delete____ID
         481                 :     };
         482                 :     Reply___delete__() :
         483                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Reply___delete__")
         484                 :     {
         485                 :     }
         486                 :
         487                 :     void
         488                 :     Log(
         489                 :             const std::string& __pfx,
         490                 :             FILE* __outf) const
         491                 :     {
         492                 :         std::string __logmsg;
         493                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         494                 :         (__logmsg).append(__pfx);
         495                 :         (__logmsg).append("Reply___delete__(");
         496                 :
         497                 :         (__logmsg).append("[TODO])\n");
         498                 :         fputs((__logmsg).c_str(), __outf);
         499                 :     }
         500                 : };
         501                 :
         502                 : class Msg_OnStartRequest :
         503                 :     public IPC::Message
         504               0 : {
         505                 : private:
         506                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         507                 :     typedef mozilla::ipc::Shmem Shmem;
         508                 :     typedef IPC::URI URI;
         509                 :     typedef IPC::InputStream InputStream;
         510                 :
         511                 : public:
         512                 :     enum {
         513                 :         ID = Msg_OnStartRequest__ID
         514                 :     };
         515               0 :     Msg_OnStartRequest() :
         516               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_OnStartRequest")
         517                 :     {
         518               0 :     }
         519                 :
         520                 :     void
         521               0 :     Log(
         522                 :             const std::string& __pfx,
         523                 :             FILE* __outf) const
         524                 :     {
         525               0 :         std::string __logmsg;
         526               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         527               0 :         (__logmsg).append(__pfx);
         528               0 :         (__logmsg).append("Msg_OnStartRequest(");
         529                 :
         530               0 :         (__logmsg).append("[TODO])\n");
         531               0 :         fputs((__logmsg).c_str(), __outf);
         532               0 :     }
         533                 : };
         534                 :
         535                 : class Msg_OnTransportAndData :
         536                 :     public IPC::Message
         537               0 : {
         538                 : private:
         539                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         540                 :     typedef mozilla::ipc::Shmem Shmem;
         541                 :     typedef IPC::URI URI;
         542                 :     typedef IPC::InputStream InputStream;
         543                 :
         544                 : public:
         545                 :     enum {
         546                 :         ID = Msg_OnTransportAndData__ID
         547                 :     };
         548               0 :     Msg_OnTransportAndData() :
         549               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_OnTransportAndData")
         550                 :     {
         551               0 :     }
         552                 :
         553                 :     void
         554               0 :     Log(
         555                 :             const std::string& __pfx,
         556                 :             FILE* __outf) const
         557                 :     {
         558               0 :         std::string __logmsg;
         559               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         560               0 :         (__logmsg).append(__pfx);
         561               0 :         (__logmsg).append("Msg_OnTransportAndData(");
         562                 :
         563               0 :         (__logmsg).append("[TODO])\n");
         564               0 :         fputs((__logmsg).c_str(), __outf);
         565               0 :     }
         566                 : };
         567                 :
         568                 : class Msg_OnStopRequest :
         569                 :     public IPC::Message
         570               0 : {
         571                 : private:
         572                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         573                 :     typedef mozilla::ipc::Shmem Shmem;
         574                 :     typedef IPC::URI URI;
         575                 :     typedef IPC::InputStream InputStream;
         576                 :
         577                 : public:
         578                 :     enum {
         579                 :         ID = Msg_OnStopRequest__ID
         580                 :     };
         581               0 :     Msg_OnStopRequest() :
         582               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_OnStopRequest")
         583                 :     {
         584               0 :     }
         585                 :
         586                 :     void
         587               0 :     Log(
         588                 :             const std::string& __pfx,
         589                 :             FILE* __outf) const
         590                 :     {
         591               0 :         std::string __logmsg;
         592               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         593               0 :         (__logmsg).append(__pfx);
         594               0 :         (__logmsg).append("Msg_OnStopRequest(");
         595                 :
         596               0 :         (__logmsg).append("[TODO])\n");
         597               0 :         fputs((__logmsg).c_str(), __outf);
         598               0 :     }
         599                 : };
         600                 :
         601                 : class Msg_OnProgress :
         602                 :     public IPC::Message
         603               0 : {
         604                 : private:
         605                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         606                 :     typedef mozilla::ipc::Shmem Shmem;
         607                 :     typedef IPC::URI URI;
         608                 :     typedef IPC::InputStream InputStream;
         609                 :
         610                 : public:
         611                 :     enum {
         612                 :         ID = Msg_OnProgress__ID
         613                 :     };
         614               0 :     Msg_OnProgress() :
         615               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_OnProgress")
         616                 :     {
         617               0 :     }
         618                 :
         619                 :     void
         620               0 :     Log(
         621                 :             const std::string& __pfx,
         622                 :             FILE* __outf) const
         623                 :     {
         624               0 :         std::string __logmsg;
         625               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         626               0 :         (__logmsg).append(__pfx);
         627               0 :         (__logmsg).append("Msg_OnProgress(");
         628                 :
         629               0 :         (__logmsg).append("[TODO])\n");
         630               0 :         fputs((__logmsg).c_str(), __outf);
         631               0 :     }
         632                 : };
         633                 :
         634                 : class Msg_OnStatus :
         635                 :     public IPC::Message
         636               0 : {
         637                 : private:
         638                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         639                 :     typedef mozilla::ipc::Shmem Shmem;
         640                 :     typedef IPC::URI URI;
         641                 :     typedef IPC::InputStream InputStream;
         642                 :
         643                 : public:
         644                 :     enum {
         645                 :         ID = Msg_OnStatus__ID
         646                 :     };
         647               0 :     Msg_OnStatus() :
         648               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_OnStatus")
         649                 :     {
         650               0 :     }
         651                 :
         652                 :     void
         653               0 :     Log(
         654                 :             const std::string& __pfx,
         655                 :             FILE* __outf) const
         656                 :     {
         657               0 :         std::string __logmsg;
         658               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         659               0 :         (__logmsg).append(__pfx);
         660               0 :         (__logmsg).append("Msg_OnStatus(");
         661                 :
         662               0 :         (__logmsg).append("[TODO])\n");
         663               0 :         fputs((__logmsg).c_str(), __outf);
         664               0 :     }
         665                 : };
         666                 :
         667                 : class Msg_FailedAsyncOpen :
         668                 :     public IPC::Message
         669               0 : {
         670                 : private:
         671                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         672                 :     typedef mozilla::ipc::Shmem Shmem;
         673                 :     typedef IPC::URI URI;
         674                 :     typedef IPC::InputStream InputStream;
         675                 :
         676                 : public:
         677                 :     enum {
         678                 :         ID = Msg_FailedAsyncOpen__ID
         679                 :     };
         680               0 :     Msg_FailedAsyncOpen() :
         681               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_FailedAsyncOpen")
         682                 :     {
         683               0 :     }
         684                 :
         685                 :     void
         686               0 :     Log(
         687                 :             const std::string& __pfx,
         688                 :             FILE* __outf) const
         689                 :     {
         690               0 :         std::string __logmsg;
         691               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         692               0 :         (__logmsg).append(__pfx);
         693               0 :         (__logmsg).append("Msg_FailedAsyncOpen(");
         694                 :
         695               0 :         (__logmsg).append("[TODO])\n");
         696               0 :         fputs((__logmsg).c_str(), __outf);
         697               0 :     }
         698                 : };
         699                 :
         700                 : class Msg_Redirect1Begin :
         701                 :     public IPC::Message
         702               0 : {
         703                 : private:
         704                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         705                 :     typedef mozilla::ipc::Shmem Shmem;
         706                 :     typedef IPC::URI URI;
         707                 :     typedef IPC::InputStream InputStream;
         708                 :
         709                 : public:
         710                 :     enum {
         711                 :         ID = Msg_Redirect1Begin__ID
         712                 :     };
         713               0 :     Msg_Redirect1Begin() :
         714               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Redirect1Begin")
         715                 :     {
         716               0 :     }
         717                 :
         718                 :     void
         719               0 :     Log(
         720                 :             const std::string& __pfx,
         721                 :             FILE* __outf) const
         722                 :     {
         723               0 :         std::string __logmsg;
         724               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         725               0 :         (__logmsg).append(__pfx);
         726               0 :         (__logmsg).append("Msg_Redirect1Begin(");
         727                 :
         728               0 :         (__logmsg).append("[TODO])\n");
         729               0 :         fputs((__logmsg).c_str(), __outf);
         730               0 :     }
         731                 : };
         732                 :
         733                 : class Msg_Redirect3Complete :
         734                 :     public IPC::Message
         735               0 : {
         736                 : private:
         737                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         738                 :     typedef mozilla::ipc::Shmem Shmem;
         739                 :     typedef IPC::URI URI;
         740                 :     typedef IPC::InputStream InputStream;
         741                 :
         742                 : public:
         743                 :     enum {
         744                 :         ID = Msg_Redirect3Complete__ID
         745                 :     };
         746               0 :     Msg_Redirect3Complete() :
         747               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_Redirect3Complete")
         748                 :     {
         749               0 :     }
         750                 :
         751                 :     void
         752               0 :     Log(
         753                 :             const std::string& __pfx,
         754                 :             FILE* __outf) const
         755                 :     {
         756               0 :         std::string __logmsg;
         757               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         758               0 :         (__logmsg).append(__pfx);
         759               0 :         (__logmsg).append("Msg_Redirect3Complete(");
         760                 :
         761               0 :         (__logmsg).append("[TODO])\n");
         762               0 :         fputs((__logmsg).c_str(), __outf);
         763               0 :     }
         764                 : };
         765                 :
         766                 : class Msg_AssociateApplicationCache :
         767                 :     public IPC::Message
         768               0 : {
         769                 : private:
         770                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         771                 :     typedef mozilla::ipc::Shmem Shmem;
         772                 :     typedef IPC::URI URI;
         773                 :     typedef IPC::InputStream InputStream;
         774                 :
         775                 : public:
         776                 :     enum {
         777                 :         ID = Msg_AssociateApplicationCache__ID
         778                 :     };
         779               0 :     Msg_AssociateApplicationCache() :
         780               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_AssociateApplicationCache")
         781                 :     {
         782               0 :     }
         783                 :
         784                 :     void
         785               0 :     Log(
         786                 :             const std::string& __pfx,
         787                 :             FILE* __outf) const
         788                 :     {
         789               0 :         std::string __logmsg;
         790               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         791               0 :         (__logmsg).append(__pfx);
         792               0 :         (__logmsg).append("Msg_AssociateApplicationCache(");
         793                 :
         794               0 :         (__logmsg).append("[TODO])\n");
         795               0 :         fputs((__logmsg).c_str(), __outf);
         796               0 :     }
         797                 : };
         798                 :
         799                 : class Msg_DeleteSelf :
         800                 :     public IPC::Message
         801               0 : {
         802                 : private:
         803                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         804                 :     typedef mozilla::ipc::Shmem Shmem;
         805                 :     typedef IPC::URI URI;
         806                 :     typedef IPC::InputStream InputStream;
         807                 :
         808                 : public:
         809                 :     enum {
         810                 :         ID = Msg_DeleteSelf__ID
         811                 :     };
         812               0 :     Msg_DeleteSelf() :
         813               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PHttpChannel::Msg_DeleteSelf")
         814                 :     {
         815               0 :     }
         816                 :
         817                 :     void
         818               0 :     Log(
         819                 :             const std::string& __pfx,
         820                 :             FILE* __outf) const
         821                 :     {
         822               0 :         std::string __logmsg;
         823               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         824               0 :         (__logmsg).append(__pfx);
         825               0 :         (__logmsg).append("Msg_DeleteSelf(");
         826                 :
         827               0 :         (__logmsg).append("[TODO])\n");
         828               0 :         fputs((__logmsg).c_str(), __outf);
         829               0 :     }
         830                 : };
         831                 :
         832                 :
         833                 :
         834                 : } // namespace PHttpChannel
         835                 : } // namespace net
         836                 : } // namespace mozilla
         837                 :
         838                 : #endif // ifndef PHttpChannel_h

Generated by: LCOV version 1.7