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

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

           1                 : //
           2                 : // Automatically generated by ipdlc.
           3                 : // Edit at your own risk
           4                 : //
           5                 :
           6                 : #ifndef PNecko_h
           7                 : #define PNecko_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                 :
          21                 : //-----------------------------------------------------------------------------
          22                 : // Code common to PNeckoChild and PNeckoParent
          23                 : //
          24                 : namespace mozilla {
          25                 : namespace net {
          26                 : namespace PNecko {
          27                 :
          28                 : enum State {
          29                 :     __Dead,
          30                 :     __Null,
          31                 :     __Error,
          32                 :     __Start = __Null
          33                 : };
          34                 :
          35                 : enum MessageType {
          36                 :     PNeckoStart = PNeckoMsgStart << 16,
          37                 :     PNeckoPreStart = (PNeckoMsgStart << 16) - 1,
          38                 :     Msg___delete____ID,
          39                 :     Reply___delete____ID,
          40                 :     Msg_PCookieServiceConstructor__ID,
          41                 :     Reply_PCookieServiceConstructor__ID,
          42                 :     Msg_PWyciwygChannelConstructor__ID,
          43                 :     Reply_PWyciwygChannelConstructor__ID,
          44                 :     Msg_PFTPChannelConstructor__ID,
          45                 :     Reply_PFTPChannelConstructor__ID,
          46                 :     Msg_PWebSocketConstructor__ID,
          47                 :     Reply_PWebSocketConstructor__ID,
          48                 :     Msg_HTMLDNSPrefetch__ID,
          49                 :     Msg_CancelHTMLDNSPrefetch__ID,
          50                 :     Msg_PHttpChannelConstructor__ID,
          51                 :     Reply_PHttpChannelConstructor__ID,
          52                 :     PNeckoEnd
          53                 : };
          54                 :
          55                 : bool
          56                 : Transition(
          57                 :         State from,
          58                 :         mozilla::ipc::Trigger trigger,
          59                 :         State* next);
          60                 :
          61                 : class Msg___delete__ :
          62                 :     public IPC::Message
          63               0 : {
          64                 : private:
          65                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
          66                 :     typedef mozilla::ipc::Shmem Shmem;
          67                 :
          68                 : public:
          69                 :     enum {
          70                 :         ID = Msg___delete____ID
          71                 :     };
          72               0 :     Msg___delete__() :
          73               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg___delete__")
          74                 :     {
          75               0 :     }
          76                 :
          77                 :     void
          78               0 :     Log(
          79                 :             const std::string& __pfx,
          80                 :             FILE* __outf) const
          81                 :     {
          82               0 :         std::string __logmsg;
          83               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
          84               0 :         (__logmsg).append(__pfx);
          85               0 :         (__logmsg).append("Msg___delete__(");
          86                 :
          87               0 :         (__logmsg).append("[TODO])\n");
          88               0 :         fputs((__logmsg).c_str(), __outf);
          89               0 :     }
          90                 : };
          91                 :
          92                 : class Reply___delete__ :
          93                 :     public IPC::Message
          94                 : {
          95                 : private:
          96                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
          97                 :     typedef mozilla::ipc::Shmem Shmem;
          98                 :
          99                 : public:
         100                 :     enum {
         101                 :         ID = Reply___delete____ID
         102                 :     };
         103                 :     Reply___delete__() :
         104                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply___delete__")
         105                 :     {
         106                 :     }
         107                 :
         108                 :     void
         109                 :     Log(
         110                 :             const std::string& __pfx,
         111                 :             FILE* __outf) const
         112                 :     {
         113                 :         std::string __logmsg;
         114                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         115                 :         (__logmsg).append(__pfx);
         116                 :         (__logmsg).append("Reply___delete__(");
         117                 :
         118                 :         (__logmsg).append("[TODO])\n");
         119                 :         fputs((__logmsg).c_str(), __outf);
         120                 :     }
         121                 : };
         122                 :
         123                 : class Msg_PCookieServiceConstructor :
         124                 :     public IPC::Message
         125               0 : {
         126                 : private:
         127                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         128                 :     typedef mozilla::ipc::Shmem Shmem;
         129                 :
         130                 : public:
         131                 :     enum {
         132                 :         ID = Msg_PCookieServiceConstructor__ID
         133                 :     };
         134               0 :     Msg_PCookieServiceConstructor() :
         135               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_PCookieServiceConstructor")
         136                 :     {
         137               0 :     }
         138                 :
         139                 :     void
         140               0 :     Log(
         141                 :             const std::string& __pfx,
         142                 :             FILE* __outf) const
         143                 :     {
         144               0 :         std::string __logmsg;
         145               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         146               0 :         (__logmsg).append(__pfx);
         147               0 :         (__logmsg).append("Msg_PCookieServiceConstructor(");
         148                 :
         149               0 :         (__logmsg).append("[TODO])\n");
         150               0 :         fputs((__logmsg).c_str(), __outf);
         151               0 :     }
         152                 : };
         153                 :
         154                 : class Reply_PCookieServiceConstructor :
         155                 :     public IPC::Message
         156                 : {
         157                 : private:
         158                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         159                 :     typedef mozilla::ipc::Shmem Shmem;
         160                 :
         161                 : public:
         162                 :     enum {
         163                 :         ID = Reply_PCookieServiceConstructor__ID
         164                 :     };
         165                 :     Reply_PCookieServiceConstructor() :
         166                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply_PCookieServiceConstructor")
         167                 :     {
         168                 :     }
         169                 :
         170                 :     void
         171                 :     Log(
         172                 :             const std::string& __pfx,
         173                 :             FILE* __outf) const
         174                 :     {
         175                 :         std::string __logmsg;
         176                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         177                 :         (__logmsg).append(__pfx);
         178                 :         (__logmsg).append("Reply_PCookieServiceConstructor(");
         179                 :
         180                 :         (__logmsg).append("[TODO])\n");
         181                 :         fputs((__logmsg).c_str(), __outf);
         182                 :     }
         183                 : };
         184                 :
         185                 : class Msg_PWyciwygChannelConstructor :
         186                 :     public IPC::Message
         187               0 : {
         188                 : private:
         189                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         190                 :     typedef mozilla::ipc::Shmem Shmem;
         191                 :
         192                 : public:
         193                 :     enum {
         194                 :         ID = Msg_PWyciwygChannelConstructor__ID
         195                 :     };
         196               0 :     Msg_PWyciwygChannelConstructor() :
         197               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_PWyciwygChannelConstructor")
         198                 :     {
         199               0 :     }
         200                 :
         201                 :     void
         202               0 :     Log(
         203                 :             const std::string& __pfx,
         204                 :             FILE* __outf) const
         205                 :     {
         206               0 :         std::string __logmsg;
         207               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         208               0 :         (__logmsg).append(__pfx);
         209               0 :         (__logmsg).append("Msg_PWyciwygChannelConstructor(");
         210                 :
         211               0 :         (__logmsg).append("[TODO])\n");
         212               0 :         fputs((__logmsg).c_str(), __outf);
         213               0 :     }
         214                 : };
         215                 :
         216                 : class Reply_PWyciwygChannelConstructor :
         217                 :     public IPC::Message
         218                 : {
         219                 : private:
         220                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         221                 :     typedef mozilla::ipc::Shmem Shmem;
         222                 :
         223                 : public:
         224                 :     enum {
         225                 :         ID = Reply_PWyciwygChannelConstructor__ID
         226                 :     };
         227                 :     Reply_PWyciwygChannelConstructor() :
         228                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply_PWyciwygChannelConstructor")
         229                 :     {
         230                 :     }
         231                 :
         232                 :     void
         233                 :     Log(
         234                 :             const std::string& __pfx,
         235                 :             FILE* __outf) const
         236                 :     {
         237                 :         std::string __logmsg;
         238                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         239                 :         (__logmsg).append(__pfx);
         240                 :         (__logmsg).append("Reply_PWyciwygChannelConstructor(");
         241                 :
         242                 :         (__logmsg).append("[TODO])\n");
         243                 :         fputs((__logmsg).c_str(), __outf);
         244                 :     }
         245                 : };
         246                 :
         247                 : class Msg_PFTPChannelConstructor :
         248                 :     public IPC::Message
         249               0 : {
         250                 : private:
         251                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         252                 :     typedef mozilla::ipc::Shmem Shmem;
         253                 :
         254                 : public:
         255                 :     enum {
         256                 :         ID = Msg_PFTPChannelConstructor__ID
         257                 :     };
         258               0 :     Msg_PFTPChannelConstructor() :
         259               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_PFTPChannelConstructor")
         260                 :     {
         261               0 :     }
         262                 :
         263                 :     void
         264               0 :     Log(
         265                 :             const std::string& __pfx,
         266                 :             FILE* __outf) const
         267                 :     {
         268               0 :         std::string __logmsg;
         269               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         270               0 :         (__logmsg).append(__pfx);
         271               0 :         (__logmsg).append("Msg_PFTPChannelConstructor(");
         272                 :
         273               0 :         (__logmsg).append("[TODO])\n");
         274               0 :         fputs((__logmsg).c_str(), __outf);
         275               0 :     }
         276                 : };
         277                 :
         278                 : class Reply_PFTPChannelConstructor :
         279                 :     public IPC::Message
         280                 : {
         281                 : private:
         282                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         283                 :     typedef mozilla::ipc::Shmem Shmem;
         284                 :
         285                 : public:
         286                 :     enum {
         287                 :         ID = Reply_PFTPChannelConstructor__ID
         288                 :     };
         289                 :     Reply_PFTPChannelConstructor() :
         290                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply_PFTPChannelConstructor")
         291                 :     {
         292                 :     }
         293                 :
         294                 :     void
         295                 :     Log(
         296                 :             const std::string& __pfx,
         297                 :             FILE* __outf) const
         298                 :     {
         299                 :         std::string __logmsg;
         300                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         301                 :         (__logmsg).append(__pfx);
         302                 :         (__logmsg).append("Reply_PFTPChannelConstructor(");
         303                 :
         304                 :         (__logmsg).append("[TODO])\n");
         305                 :         fputs((__logmsg).c_str(), __outf);
         306                 :     }
         307                 : };
         308                 :
         309                 : class Msg_PWebSocketConstructor :
         310                 :     public IPC::Message
         311               0 : {
         312                 : private:
         313                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         314                 :     typedef mozilla::ipc::Shmem Shmem;
         315                 :
         316                 : public:
         317                 :     enum {
         318                 :         ID = Msg_PWebSocketConstructor__ID
         319                 :     };
         320               0 :     Msg_PWebSocketConstructor() :
         321               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_PWebSocketConstructor")
         322                 :     {
         323               0 :     }
         324                 :
         325                 :     void
         326               0 :     Log(
         327                 :             const std::string& __pfx,
         328                 :             FILE* __outf) const
         329                 :     {
         330               0 :         std::string __logmsg;
         331               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         332               0 :         (__logmsg).append(__pfx);
         333               0 :         (__logmsg).append("Msg_PWebSocketConstructor(");
         334                 :
         335               0 :         (__logmsg).append("[TODO])\n");
         336               0 :         fputs((__logmsg).c_str(), __outf);
         337               0 :     }
         338                 : };
         339                 :
         340                 : class Reply_PWebSocketConstructor :
         341                 :     public IPC::Message
         342                 : {
         343                 : private:
         344                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         345                 :     typedef mozilla::ipc::Shmem Shmem;
         346                 :
         347                 : public:
         348                 :     enum {
         349                 :         ID = Reply_PWebSocketConstructor__ID
         350                 :     };
         351                 :     Reply_PWebSocketConstructor() :
         352                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply_PWebSocketConstructor")
         353                 :     {
         354                 :     }
         355                 :
         356                 :     void
         357                 :     Log(
         358                 :             const std::string& __pfx,
         359                 :             FILE* __outf) const
         360                 :     {
         361                 :         std::string __logmsg;
         362                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         363                 :         (__logmsg).append(__pfx);
         364                 :         (__logmsg).append("Reply_PWebSocketConstructor(");
         365                 :
         366                 :         (__logmsg).append("[TODO])\n");
         367                 :         fputs((__logmsg).c_str(), __outf);
         368                 :     }
         369                 : };
         370                 :
         371                 : class Msg_HTMLDNSPrefetch :
         372                 :     public IPC::Message
         373               0 : {
         374                 : private:
         375                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         376                 :     typedef mozilla::ipc::Shmem Shmem;
         377                 :
         378                 : public:
         379                 :     enum {
         380                 :         ID = Msg_HTMLDNSPrefetch__ID
         381                 :     };
         382               0 :     Msg_HTMLDNSPrefetch() :
         383               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_HTMLDNSPrefetch")
         384                 :     {
         385               0 :     }
         386                 :
         387                 :     void
         388               0 :     Log(
         389                 :             const std::string& __pfx,
         390                 :             FILE* __outf) const
         391                 :     {
         392               0 :         std::string __logmsg;
         393               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         394               0 :         (__logmsg).append(__pfx);
         395               0 :         (__logmsg).append("Msg_HTMLDNSPrefetch(");
         396                 :
         397               0 :         (__logmsg).append("[TODO])\n");
         398               0 :         fputs((__logmsg).c_str(), __outf);
         399               0 :     }
         400                 : };
         401                 :
         402                 : class Msg_CancelHTMLDNSPrefetch :
         403                 :     public IPC::Message
         404               0 : {
         405                 : private:
         406                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         407                 :     typedef mozilla::ipc::Shmem Shmem;
         408                 :
         409                 : public:
         410                 :     enum {
         411                 :         ID = Msg_CancelHTMLDNSPrefetch__ID
         412                 :     };
         413               0 :     Msg_CancelHTMLDNSPrefetch() :
         414               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_CancelHTMLDNSPrefetch")
         415                 :     {
         416               0 :     }
         417                 :
         418                 :     void
         419               0 :     Log(
         420                 :             const std::string& __pfx,
         421                 :             FILE* __outf) const
         422                 :     {
         423               0 :         std::string __logmsg;
         424               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         425               0 :         (__logmsg).append(__pfx);
         426               0 :         (__logmsg).append("Msg_CancelHTMLDNSPrefetch(");
         427                 :
         428               0 :         (__logmsg).append("[TODO])\n");
         429               0 :         fputs((__logmsg).c_str(), __outf);
         430               0 :     }
         431                 : };
         432                 :
         433                 : class Msg_PHttpChannelConstructor :
         434                 :     public IPC::Message
         435               0 : {
         436                 : private:
         437                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         438                 :     typedef mozilla::ipc::Shmem Shmem;
         439                 :
         440                 : public:
         441                 :     enum {
         442                 :         ID = Msg_PHttpChannelConstructor__ID
         443                 :     };
         444               0 :     Msg_PHttpChannelConstructor() :
         445               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Msg_PHttpChannelConstructor")
         446                 :     {
         447               0 :     }
         448                 :
         449                 :     void
         450               0 :     Log(
         451                 :             const std::string& __pfx,
         452                 :             FILE* __outf) const
         453                 :     {
         454               0 :         std::string __logmsg;
         455               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         456               0 :         (__logmsg).append(__pfx);
         457               0 :         (__logmsg).append("Msg_PHttpChannelConstructor(");
         458                 :
         459               0 :         (__logmsg).append("[TODO])\n");
         460               0 :         fputs((__logmsg).c_str(), __outf);
         461               0 :     }
         462                 : };
         463                 :
         464                 : class Reply_PHttpChannelConstructor :
         465                 :     public IPC::Message
         466                 : {
         467                 : private:
         468                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         469                 :     typedef mozilla::ipc::Shmem Shmem;
         470                 :
         471                 : public:
         472                 :     enum {
         473                 :         ID = Reply_PHttpChannelConstructor__ID
         474                 :     };
         475                 :     Reply_PHttpChannelConstructor() :
         476                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PNecko::Reply_PHttpChannelConstructor")
         477                 :     {
         478                 :     }
         479                 :
         480                 :     void
         481                 :     Log(
         482                 :             const std::string& __pfx,
         483                 :             FILE* __outf) const
         484                 :     {
         485                 :         std::string __logmsg;
         486                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         487                 :         (__logmsg).append(__pfx);
         488                 :         (__logmsg).append("Reply_PHttpChannelConstructor(");
         489                 :
         490                 :         (__logmsg).append("[TODO])\n");
         491                 :         fputs((__logmsg).c_str(), __outf);
         492                 :     }
         493                 : };
         494                 :
         495                 :
         496                 :
         497                 : } // namespace PNecko
         498                 : } // namespace net
         499                 : } // namespace mozilla
         500                 :
         501                 : #endif // ifndef PNecko_h

Generated by: LCOV version 1.7