LCOV - app.info - objdir/ipc/ipdl/_ipdlheaders/mozilla/dom/PContent.h

LCOV - code coverage report
| Current view: | directory - objdir/ipc/ipdl/_ipdlheaders/mozilla/dom - PContent.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 840 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 287 | 0 | 0.0 %

           1                 : //
           2                 : // Automatically generated by ipdlc.
           3                 : // Edit at your own risk
           4                 : //
           5                 :
           6                 : #ifndef PContent_h
           7                 : #define PContent_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/chrome/RegistryMessageUtils.h"
          21                 : #include "mozilla/net/NeckoMessageUtils.h"
          22                 : #include "mozilla/dom/TabMessageUtils.h"
          23                 : #include "nsGeoPositionIPCSerialiser.h"
          24                 : #include "PPrefTuple.h"
          25                 :
          26                 : namespace mozilla {
          27                 : namespace dom {
          28                 : class PStorageParent;
          29                 : } // namespace dom
          30                 : } // namespace mozilla
          31                 :
          32                 : namespace mozilla {
          33                 : namespace dom {
          34                 : class PStorageChild;
          35                 : } // namespace dom
          36                 : } // namespace mozilla
          37                 :
          38                 :
          39                 : //-----------------------------------------------------------------------------
          40                 : // Declaration of the IPDL type |struct StorageClone|
          41                 : //
          42                 : namespace mozilla {
          43                 : namespace dom {
          44                 : class StorageClone MOZ_FINAL
          45                 : {
          46                 : private:
          47                 :     typedef mozilla::dom::PStorageParent PStorageParent;
          48                 :     typedef mozilla::dom::PStorageChild PStorageChild;
          49                 :
          50                 : public:
          51                 :     StorageClone();
          52                 :
          53               0 :     StorageClone(
          54                 :             PStorageParent* _actorParent,
          55                 :             PStorageChild* _actorChild,
          56                 :             const bool& _callerSecure)
          57                 :     {
          58               0 :         Init();
          59               0 :         Assign(_actorParent, _actorChild, _callerSecure);
          60               0 :     }
          61                 :
          62               0 :     StorageClone(const StorageClone& _o)
          63                 :     {
          64               0 :         Init();
          65               0 :         Assign(const_cast<PStorageParent*>((_o).actorParent()), const_cast<PStorageChild*>((_o).actorChild()), (_o).callerSecure());
          66               0 :     }
          67                 :
          68                 :     ~StorageClone();
          69                 :
          70                 :     void
          71               0 :     operator=(const StorageClone& _o)
          72                 :     {
          73               0 :         Assign(const_cast<PStorageParent*>((_o).actorParent()), const_cast<PStorageChild*>((_o).actorChild()), (_o).callerSecure());
          74               0 :     }
          75                 :
          76                 :     bool
          77                 :     operator==(const StorageClone& _o) const;
          78                 :
          79                 :     PStorageParent*&
          80               0 :     actorParent()
          81                 :     {
          82               0 :         return actorParent_;
          83                 :     }
          84                 :     PStorageParent*
          85               0 :     actorParent() const
          86                 :     {
          87               0 :         return actorParent_;
          88                 :     }
          89                 :
          90                 :     PStorageChild*&
          91               0 :     actorChild()
          92                 :     {
          93               0 :         return actorChild_;
          94                 :     }
          95                 :     PStorageChild*
          96               0 :     actorChild() const
          97                 :     {
          98               0 :         return actorChild_;
          99                 :     }
         100                 :
         101                 :     bool&
         102               0 :     callerSecure()
         103                 :     {
         104               0 :         return callerSecure_;
         105                 :     }
         106                 :     const bool&
         107               0 :     callerSecure() const
         108                 :     {
         109               0 :         return callerSecure_;
         110                 :     }
         111                 :
         112                 : private:
         113                 :     void
         114                 :     Init();
         115                 :
         116                 :     void
         117                 :     Assign(
         118                 :             PStorageParent* _actorParent,
         119                 :             PStorageChild* _actorChild,
         120                 :             const bool& _callerSecure);
         121                 :
         122                 :     PStorageParent* actorParent_;
         123                 :     PStorageChild* actorChild_;
         124                 :     bool callerSecure_;
         125                 : };
         126                 : } // namespace dom
         127                 : } // namespace mozilla
         128                 :
         129                 : namespace mozilla {
         130                 : namespace dom {
         131                 : class StorageClone;
         132                 : } // namespace dom
         133                 : } // namespace mozilla
         134                 :
         135                 : //-----------------------------------------------------------------------------
         136                 : // Declaration of the IPDL type |union StorageConstructData|
         137                 : //
         138                 : namespace mozilla {
         139                 : namespace dom {
         140                 : class StorageConstructData MOZ_FINAL
         141                 : {
         142                 : public:
         143                 :     enum Type {
         144                 :         T__None,
         145                 :         Tnull_t = 1,
         146                 :         TStorageClone,
         147                 :         T__Last = TStorageClone
         148                 :     };
         149                 :
         150                 : private:
         151                 :     typedef mozilla::null_t null_t;
         152                 :     typedef mozilla::dom::StorageClone StorageClone;
         153                 :     typedef null_t null_t__tdef;
         154                 :     typedef StorageClone StorageClone__tdef;
         155                 :
         156                 :     union Value {
         157                 :         char Vnull_t[sizeof(null_t)];
         158                 :         char VStorageClone[sizeof(StorageClone)];
         159                 :     };
         160                 :
         161                 :     null_t*
         162               0 :     ptr_null_t()
         163                 :     {
         164               0 :         return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
         165                 :     }
         166                 :     const null_t* const
         167               0 :     constptr_null_t() const
         168                 :     {
         169               0 :         return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
         170                 :     }
         171                 :     StorageClone*
         172               0 :     ptr_StorageClone()
         173                 :     {
         174               0 :         return reinterpret_cast<StorageClone*>((&((mValue).VStorageClone)));
         175                 :     }
         176                 :     const StorageClone* const
         177               0 :     constptr_StorageClone() const
         178                 :     {
         179               0 :         return reinterpret_cast<const StorageClone* const>((&((mValue).VStorageClone)));
         180                 :     }
         181                 :
         182                 :     bool
         183                 :     MaybeDestroy(Type aNewType);
         184                 :
         185                 :     void
         186               0 :     AssertSanity() const
         187                 :     {
         188               0 :         NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
         189               0 :         NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
         190               0 :     }
         191                 :     void
         192               0 :     AssertSanity(Type aType) const
         193                 :     {
         194               0 :         AssertSanity();
         195               0 :         NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
         196               0 :     }
         197                 :
         198                 : public:
         199               0 :     StorageConstructData() :
         200               0 :         mType(T__None)
         201                 :     {
         202               0 :     }
         203                 :
         204                 :     StorageConstructData(const null_t& aOther);
         205                 :
         206                 :     StorageConstructData(const StorageClone& aOther);
         207                 :
         208                 :     StorageConstructData(const StorageConstructData& aOther);
         209                 :
         210                 :     ~StorageConstructData();
         211                 :
         212                 :     Type
         213               0 :     type() const
         214                 :     {
         215               0 :         return mType;
         216                 :     }
         217                 :
         218                 :     StorageConstructData&
         219                 :     operator=(const null_t& aRhs);
         220                 :
         221                 :     StorageConstructData&
         222                 :     operator=(const StorageClone& aRhs);
         223                 :
         224                 :     StorageConstructData&
         225                 :     operator=(const StorageConstructData& aRhs);
         226                 :
         227                 :     bool
         228                 :     operator==(const null_t& aRhs) const;
         229                 :
         230                 :     bool
         231                 :     operator==(const StorageClone& aRhs) const;
         232                 :
         233                 :     bool
         234                 :     operator==(const StorageConstructData& aRhs) const;
         235                 :
         236                 :     null_t&
         237               0 :     get_null_t()
         238                 :     {
         239               0 :         AssertSanity(Tnull_t);
         240               0 :         return (*(ptr_null_t()));
         241                 :     }
         242                 :     const null_t&
         243               0 :     get_null_t() const
         244                 :     {
         245               0 :         AssertSanity(Tnull_t);
         246               0 :         return (*(constptr_null_t()));
         247                 :     }
         248                 :     operator null_t&()
         249                 :     {
         250                 :         return get_null_t();
         251                 :     }
         252                 :     operator const null_t&() const
         253                 :     {
         254                 :         return get_null_t();
         255                 :     }
         256                 :
         257                 :     StorageClone&
         258               0 :     get_StorageClone()
         259                 :     {
         260               0 :         AssertSanity(TStorageClone);
         261               0 :         return (*(ptr_StorageClone()));
         262                 :     }
         263                 :     const StorageClone&
         264               0 :     get_StorageClone() const
         265                 :     {
         266               0 :         AssertSanity(TStorageClone);
         267               0 :         return (*(constptr_StorageClone()));
         268                 :     }
         269                 :     operator StorageClone&()
         270                 :     {
         271                 :         return get_StorageClone();
         272                 :     }
         273                 :     operator const StorageClone&() const
         274                 :     {
         275                 :         return get_StorageClone();
         276                 :     }
         277                 :
         278                 : private:
         279                 :     Value mValue;
         280                 :     Type mType;
         281                 : };
         282                 : } // namespace dom
         283                 : } // namespace mozilla
         284                 :
         285                 :
         286                 : //-----------------------------------------------------------------------------
         287                 : // Declaration of the IPDL type |struct FontListEntry|
         288                 : //
         289                 : namespace mozilla {
         290                 : namespace dom {
         291                 : class FontListEntry MOZ_FINAL
         292                 : {
         293                 : private:
         294                 :
         295                 : public:
         296                 :     FontListEntry();
         297                 :
         298                 :     FontListEntry(
         299                 :             const nsString& _familyName,
         300                 :             const nsString& _faceName,
         301                 :             const nsCString& _filepath,
         302                 :             const PRUint16& _weight,
         303                 :             const PRInt16& _stretch,
         304                 :             const PRUint8& _italic,
         305                 :             const PRUint8& _index)
         306                 :     {
         307                 :         Init();
         308                 :         Assign(_familyName, _faceName, _filepath, _weight, _stretch, _italic, _index);
         309                 :     }
         310                 :
         311                 :     FontListEntry(const FontListEntry& _o)
         312                 :     {
         313                 :         Init();
         314                 :         Assign((_o).familyName(), (_o).faceName(), (_o).filepath(), (_o).weight(), (_o).stretch(), (_o).italic(), (_o).index());
         315                 :     }
         316                 :
         317                 :     ~FontListEntry();
         318                 :
         319                 :     void
         320                 :     operator=(const FontListEntry& _o)
         321                 :     {
         322                 :         Assign((_o).familyName(), (_o).faceName(), (_o).filepath(), (_o).weight(), (_o).stretch(), (_o).italic(), (_o).index());
         323                 :     }
         324                 :
         325                 :     bool
         326                 :     operator==(const FontListEntry& _o) const;
         327                 :
         328                 :     nsString&
         329               0 :     familyName()
         330                 :     {
         331               0 :         return familyName_;
         332                 :     }
         333                 :     const nsString&
         334               0 :     familyName() const
         335                 :     {
         336               0 :         return familyName_;
         337                 :     }
         338                 :
         339                 :     nsString&
         340               0 :     faceName()
         341                 :     {
         342               0 :         return faceName_;
         343                 :     }
         344                 :     const nsString&
         345               0 :     faceName() const
         346                 :     {
         347               0 :         return faceName_;
         348                 :     }
         349                 :
         350                 :     nsCString&
         351               0 :     filepath()
         352                 :     {
         353               0 :         return filepath_;
         354                 :     }
         355                 :     const nsCString&
         356               0 :     filepath() const
         357                 :     {
         358               0 :         return filepath_;
         359                 :     }
         360                 :
         361                 :     PRUint16&
         362               0 :     weight()
         363                 :     {
         364               0 :         return weight_;
         365                 :     }
         366                 :     const PRUint16&
         367               0 :     weight() const
         368                 :     {
         369               0 :         return weight_;
         370                 :     }
         371                 :
         372                 :     PRInt16&
         373               0 :     stretch()
         374                 :     {
         375               0 :         return stretch_;
         376                 :     }
         377                 :     const PRInt16&
         378               0 :     stretch() const
         379                 :     {
         380               0 :         return stretch_;
         381                 :     }
         382                 :
         383                 :     PRUint8&
         384               0 :     italic()
         385                 :     {
         386               0 :         return italic_;
         387                 :     }
         388                 :     const PRUint8&
         389               0 :     italic() const
         390                 :     {
         391               0 :         return italic_;
         392                 :     }
         393                 :
         394                 :     PRUint8&
         395               0 :     index()
         396                 :     {
         397               0 :         return index_;
         398                 :     }
         399                 :     const PRUint8&
         400               0 :     index() const
         401                 :     {
         402               0 :         return index_;
         403                 :     }
         404                 :
         405                 : private:
         406                 :     void
         407                 :     Init();
         408                 :
         409                 :     void
         410                 :     Assign(
         411                 :             const nsString& _familyName,
         412                 :             const nsString& _faceName,
         413                 :             const nsCString& _filepath,
         414                 :             const PRUint16& _weight,
         415                 :             const PRInt16& _stretch,
         416                 :             const PRUint8& _italic,
         417                 :             const PRUint8& _index);
         418                 :
         419                 :     nsString familyName_;
         420                 :     nsString faceName_;
         421                 :     nsCString filepath_;
         422                 :     PRUint16 weight_;
         423                 :     PRInt16 stretch_;
         424                 :     PRUint8 italic_;
         425                 :     PRUint8 index_;
         426                 : };
         427                 : } // namespace dom
         428                 : } // namespace mozilla
         429                 :
         430                 : //-----------------------------------------------------------------------------
         431                 : // Code common to PContentChild and PContentParent
         432                 : //
         433                 : namespace mozilla {
         434                 : namespace dom {
         435                 : namespace PContent {
         436                 :
         437                 : enum State {
         438                 :     __Dead,
         439                 :     __Null,
         440                 :     __Error,
         441                 :     __Start = __Null
         442                 : };
         443                 :
         444                 : enum MessageType {
         445                 :     PContentStart = PContentMsgStart << 16,
         446                 :     PContentPreStart = (PContentMsgStart << 16) - 1,
         447                 :     Msg_PBrowserConstructor__ID,
         448                 :     Reply_PBrowserConstructor__ID,
         449                 :     Msg_PMemoryReportRequestConstructor__ID,
         450                 :     Reply_PMemoryReportRequestConstructor__ID,
         451                 :     Msg_PTestShellConstructor__ID,
         452                 :     Reply_PTestShellConstructor__ID,
         453                 :     Msg_RegisterChrome__ID,
         454                 :     Msg_SetOffline__ID,
         455                 :     Msg_NotifyVisited__ID,
         456                 :     Msg_PreferenceUpdate__ID,
         457                 :     Msg_ClearUserPreference__ID,
         458                 :     Msg_NotifyAlertsObserver__ID,
         459                 :     Msg_GeolocationUpdate__ID,
         460                 :     Msg_AddPermission__ID,
         461                 :     Msg_DeviceMotionChanged__ID,
         462                 :     Msg_ScreenSizeChanged__ID,
         463                 :     Msg_FlushMemory__ID,
         464                 :     Msg_GarbageCollect__ID,
         465                 :     Msg_CycleCollect__ID,
         466                 :     Msg_ActivateA11y__ID,
         467                 :     Msg_AppInfo__ID,
         468                 :     Msg_SetID__ID,
         469                 :     Msg_PAudioConstructor__ID,
         470                 :     Reply_PAudioConstructor__ID,
         471                 :     Msg_PCrashReporterConstructor__ID,
         472                 :     Reply_PCrashReporterConstructor__ID,
         473                 :     Msg_PHalConstructor__ID,
         474                 :     Reply_PHalConstructor__ID,
         475                 :     Msg_PNeckoConstructor__ID,
         476                 :     Reply_PNeckoConstructor__ID,
         477                 :     Msg_PSmsConstructor__ID,
         478                 :     Reply_PSmsConstructor__ID,
         479                 :     Msg_PStorageConstructor__ID,
         480                 :     Reply_PStorageConstructor__ID,
         481                 :     Msg_StartVisitedQuery__ID,
         482                 :     Msg_VisitURI__ID,
         483                 :     Msg_SetURITitle__ID,
         484                 :     Msg_ShowFilePicker__ID,
         485                 :     Reply_ShowFilePicker__ID,
         486                 :     Msg_LoadURIExternal__ID,
         487                 :     Msg_ReadPrefsArray__ID,
         488                 :     Reply_ReadPrefsArray__ID,
         489                 :     Msg_ReadFontList__ID,
         490                 :     Reply_ReadFontList__ID,
         491                 :     Msg_SyncMessage__ID,
         492                 :     Reply_SyncMessage__ID,
         493                 :     Msg_ShowAlertNotification__ID,
         494                 :     Msg_PExternalHelperAppConstructor__ID,
         495                 :     Reply_PExternalHelperAppConstructor__ID,
         496                 :     Msg_AddGeolocationListener__ID,
         497                 :     Msg_RemoveGeolocationListener__ID,
         498                 :     Msg_AddDeviceMotionListener__ID,
         499                 :     Msg_RemoveDeviceMotionListener__ID,
         500                 :     Msg_ConsoleMessage__ID,
         501                 :     Msg_ScriptError__ID,
         502                 :     Msg_ReadPermissions__ID,
         503                 :     Reply_ReadPermissions__ID,
         504                 :     Msg_GetIndexedDBDirectory__ID,
         505                 :     Reply_GetIndexedDBDirectory__ID,
         506                 :     Msg_SetClipboardText__ID,
         507                 :     Msg_GetClipboardText__ID,
         508                 :     Reply_GetClipboardText__ID,
         509                 :     Msg_EmptyClipboard__ID,
         510                 :     Msg_ClipboardHasText__ID,
         511                 :     Reply_ClipboardHasText__ID,
         512                 :     Msg_GetSystemColors__ID,
         513                 :     Reply_GetSystemColors__ID,
         514                 :     Msg_GetIconForExtension__ID,
         515                 :     Reply_GetIconForExtension__ID,
         516                 :     Msg_GetShowPasswordSetting__ID,
         517                 :     Reply_GetShowPasswordSetting__ID,
         518                 :     Msg_AsyncMessage__ID,
         519                 :     PContentEnd
         520                 : };
         521                 :
         522                 : bool
         523                 : Transition(
         524                 :         State from,
         525                 :         mozilla::ipc::Trigger trigger,
         526                 :         State* next);
         527                 :
         528                 : class Msg_PBrowserConstructor :
         529                 :     public IPC::Message
         530               0 : {
         531                 : private:
         532                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         533                 :     typedef mozilla::dom::StorageClone StorageClone;
         534                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         535                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         536                 :     typedef mozilla::ipc::Shmem Shmem;
         537                 :     typedef IPC::URI URI;
         538                 :     typedef IPC::Permission Permission;
         539                 :     typedef mozilla::null_t null_t;
         540                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         541                 :
         542                 : public:
         543                 :     enum {
         544                 :         ID = Msg_PBrowserConstructor__ID
         545                 :     };
         546               0 :     Msg_PBrowserConstructor() :
         547               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PBrowserConstructor")
         548                 :     {
         549               0 :     }
         550                 :
         551                 :     void
         552               0 :     Log(
         553                 :             const std::string& __pfx,
         554                 :             FILE* __outf) const
         555                 :     {
         556               0 :         std::string __logmsg;
         557               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         558               0 :         (__logmsg).append(__pfx);
         559               0 :         (__logmsg).append("Msg_PBrowserConstructor(");
         560                 :
         561               0 :         (__logmsg).append("[TODO])\n");
         562               0 :         fputs((__logmsg).c_str(), __outf);
         563               0 :     }
         564                 : };
         565                 :
         566                 : class Reply_PBrowserConstructor :
         567                 :     public IPC::Message
         568                 : {
         569                 : private:
         570                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         571                 :     typedef mozilla::dom::StorageClone StorageClone;
         572                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         573                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         574                 :     typedef mozilla::ipc::Shmem Shmem;
         575                 :     typedef IPC::URI URI;
         576                 :     typedef IPC::Permission Permission;
         577                 :     typedef mozilla::null_t null_t;
         578                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         579                 :
         580                 : public:
         581                 :     enum {
         582                 :         ID = Reply_PBrowserConstructor__ID
         583                 :     };
         584                 :     Reply_PBrowserConstructor() :
         585                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PBrowserConstructor")
         586                 :     {
         587                 :     }
         588                 :
         589                 :     void
         590                 :     Log(
         591                 :             const std::string& __pfx,
         592                 :             FILE* __outf) const
         593                 :     {
         594                 :         std::string __logmsg;
         595                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         596                 :         (__logmsg).append(__pfx);
         597                 :         (__logmsg).append("Reply_PBrowserConstructor(");
         598                 :
         599                 :         (__logmsg).append("[TODO])\n");
         600                 :         fputs((__logmsg).c_str(), __outf);
         601                 :     }
         602                 : };
         603                 :
         604                 : class Msg_PMemoryReportRequestConstructor :
         605                 :     public IPC::Message
         606               0 : {
         607                 : private:
         608                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         609                 :     typedef mozilla::dom::StorageClone StorageClone;
         610                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         611                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         612                 :     typedef mozilla::ipc::Shmem Shmem;
         613                 :     typedef IPC::URI URI;
         614                 :     typedef IPC::Permission Permission;
         615                 :     typedef mozilla::null_t null_t;
         616                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         617                 :
         618                 : public:
         619                 :     enum {
         620                 :         ID = Msg_PMemoryReportRequestConstructor__ID
         621                 :     };
         622               0 :     Msg_PMemoryReportRequestConstructor() :
         623               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PMemoryReportRequestConstructor")
         624                 :     {
         625               0 :     }
         626                 :
         627                 :     void
         628               0 :     Log(
         629                 :             const std::string& __pfx,
         630                 :             FILE* __outf) const
         631                 :     {
         632               0 :         std::string __logmsg;
         633               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         634               0 :         (__logmsg).append(__pfx);
         635               0 :         (__logmsg).append("Msg_PMemoryReportRequestConstructor(");
         636                 :
         637               0 :         (__logmsg).append("[TODO])\n");
         638               0 :         fputs((__logmsg).c_str(), __outf);
         639               0 :     }
         640                 : };
         641                 :
         642                 : class Reply_PMemoryReportRequestConstructor :
         643                 :     public IPC::Message
         644                 : {
         645                 : private:
         646                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         647                 :     typedef mozilla::dom::StorageClone StorageClone;
         648                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         649                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         650                 :     typedef mozilla::ipc::Shmem Shmem;
         651                 :     typedef IPC::URI URI;
         652                 :     typedef IPC::Permission Permission;
         653                 :     typedef mozilla::null_t null_t;
         654                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         655                 :
         656                 : public:
         657                 :     enum {
         658                 :         ID = Reply_PMemoryReportRequestConstructor__ID
         659                 :     };
         660                 :     Reply_PMemoryReportRequestConstructor() :
         661                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PMemoryReportRequestConstructor")
         662                 :     {
         663                 :     }
         664                 :
         665                 :     void
         666                 :     Log(
         667                 :             const std::string& __pfx,
         668                 :             FILE* __outf) const
         669                 :     {
         670                 :         std::string __logmsg;
         671                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         672                 :         (__logmsg).append(__pfx);
         673                 :         (__logmsg).append("Reply_PMemoryReportRequestConstructor(");
         674                 :
         675                 :         (__logmsg).append("[TODO])\n");
         676                 :         fputs((__logmsg).c_str(), __outf);
         677                 :     }
         678                 : };
         679                 :
         680                 : class Msg_PTestShellConstructor :
         681                 :     public IPC::Message
         682               0 : {
         683                 : private:
         684                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         685                 :     typedef mozilla::dom::StorageClone StorageClone;
         686                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         687                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         688                 :     typedef mozilla::ipc::Shmem Shmem;
         689                 :     typedef IPC::URI URI;
         690                 :     typedef IPC::Permission Permission;
         691                 :     typedef mozilla::null_t null_t;
         692                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         693                 :
         694                 : public:
         695                 :     enum {
         696                 :         ID = Msg_PTestShellConstructor__ID
         697                 :     };
         698               0 :     Msg_PTestShellConstructor() :
         699               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PTestShellConstructor")
         700                 :     {
         701               0 :     }
         702                 :
         703                 :     void
         704               0 :     Log(
         705                 :             const std::string& __pfx,
         706                 :             FILE* __outf) const
         707                 :     {
         708               0 :         std::string __logmsg;
         709               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         710               0 :         (__logmsg).append(__pfx);
         711               0 :         (__logmsg).append("Msg_PTestShellConstructor(");
         712                 :
         713               0 :         (__logmsg).append("[TODO])\n");
         714               0 :         fputs((__logmsg).c_str(), __outf);
         715               0 :     }
         716                 : };
         717                 :
         718                 : class Reply_PTestShellConstructor :
         719                 :     public IPC::Message
         720                 : {
         721                 : private:
         722                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         723                 :     typedef mozilla::dom::StorageClone StorageClone;
         724                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         725                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         726                 :     typedef mozilla::ipc::Shmem Shmem;
         727                 :     typedef IPC::URI URI;
         728                 :     typedef IPC::Permission Permission;
         729                 :     typedef mozilla::null_t null_t;
         730                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         731                 :
         732                 : public:
         733                 :     enum {
         734                 :         ID = Reply_PTestShellConstructor__ID
         735                 :     };
         736                 :     Reply_PTestShellConstructor() :
         737                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PTestShellConstructor")
         738                 :     {
         739                 :     }
         740                 :
         741                 :     void
         742                 :     Log(
         743                 :             const std::string& __pfx,
         744                 :             FILE* __outf) const
         745                 :     {
         746                 :         std::string __logmsg;
         747                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         748                 :         (__logmsg).append(__pfx);
         749                 :         (__logmsg).append("Reply_PTestShellConstructor(");
         750                 :
         751                 :         (__logmsg).append("[TODO])\n");
         752                 :         fputs((__logmsg).c_str(), __outf);
         753                 :     }
         754                 : };
         755                 :
         756                 : class Msg_RegisterChrome :
         757                 :     public IPC::Message
         758               0 : {
         759                 : private:
         760                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         761                 :     typedef mozilla::dom::StorageClone StorageClone;
         762                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         763                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         764                 :     typedef mozilla::ipc::Shmem Shmem;
         765                 :     typedef IPC::URI URI;
         766                 :     typedef IPC::Permission Permission;
         767                 :     typedef mozilla::null_t null_t;
         768                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         769                 :
         770                 : public:
         771                 :     enum {
         772                 :         ID = Msg_RegisterChrome__ID
         773                 :     };
         774               0 :     Msg_RegisterChrome() :
         775               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_RegisterChrome")
         776                 :     {
         777               0 :     }
         778                 :
         779                 :     void
         780               0 :     Log(
         781                 :             const std::string& __pfx,
         782                 :             FILE* __outf) const
         783                 :     {
         784               0 :         std::string __logmsg;
         785               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         786               0 :         (__logmsg).append(__pfx);
         787               0 :         (__logmsg).append("Msg_RegisterChrome(");
         788                 :
         789               0 :         (__logmsg).append("[TODO])\n");
         790               0 :         fputs((__logmsg).c_str(), __outf);
         791               0 :     }
         792                 : };
         793                 :
         794                 : class Msg_SetOffline :
         795                 :     public IPC::Message
         796               0 : {
         797                 : private:
         798                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         799                 :     typedef mozilla::dom::StorageClone StorageClone;
         800                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         801                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         802                 :     typedef mozilla::ipc::Shmem Shmem;
         803                 :     typedef IPC::URI URI;
         804                 :     typedef IPC::Permission Permission;
         805                 :     typedef mozilla::null_t null_t;
         806                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         807                 :
         808                 : public:
         809                 :     enum {
         810                 :         ID = Msg_SetOffline__ID
         811                 :     };
         812               0 :     Msg_SetOffline() :
         813               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_SetOffline")
         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_SetOffline(");
         826                 :
         827               0 :         (__logmsg).append("[TODO])\n");
         828               0 :         fputs((__logmsg).c_str(), __outf);
         829               0 :     }
         830                 : };
         831                 :
         832                 : class Msg_NotifyVisited :
         833                 :     public IPC::Message
         834               0 : {
         835                 : private:
         836                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         837                 :     typedef mozilla::dom::StorageClone StorageClone;
         838                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         839                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         840                 :     typedef mozilla::ipc::Shmem Shmem;
         841                 :     typedef IPC::URI URI;
         842                 :     typedef IPC::Permission Permission;
         843                 :     typedef mozilla::null_t null_t;
         844                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         845                 :
         846                 : public:
         847                 :     enum {
         848                 :         ID = Msg_NotifyVisited__ID
         849                 :     };
         850               0 :     Msg_NotifyVisited() :
         851               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_NotifyVisited")
         852                 :     {
         853               0 :     }
         854                 :
         855                 :     void
         856               0 :     Log(
         857                 :             const std::string& __pfx,
         858                 :             FILE* __outf) const
         859                 :     {
         860               0 :         std::string __logmsg;
         861               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         862               0 :         (__logmsg).append(__pfx);
         863               0 :         (__logmsg).append("Msg_NotifyVisited(");
         864                 :
         865               0 :         (__logmsg).append("[TODO])\n");
         866               0 :         fputs((__logmsg).c_str(), __outf);
         867               0 :     }
         868                 : };
         869                 :
         870                 : class Msg_PreferenceUpdate :
         871                 :     public IPC::Message
         872               0 : {
         873                 : private:
         874                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         875                 :     typedef mozilla::dom::StorageClone StorageClone;
         876                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         877                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         878                 :     typedef mozilla::ipc::Shmem Shmem;
         879                 :     typedef IPC::URI URI;
         880                 :     typedef IPC::Permission Permission;
         881                 :     typedef mozilla::null_t null_t;
         882                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         883                 :
         884                 : public:
         885                 :     enum {
         886                 :         ID = Msg_PreferenceUpdate__ID
         887                 :     };
         888               0 :     Msg_PreferenceUpdate() :
         889               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PreferenceUpdate")
         890                 :     {
         891               0 :     }
         892                 :
         893                 :     void
         894               0 :     Log(
         895                 :             const std::string& __pfx,
         896                 :             FILE* __outf) const
         897                 :     {
         898               0 :         std::string __logmsg;
         899               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         900               0 :         (__logmsg).append(__pfx);
         901               0 :         (__logmsg).append("Msg_PreferenceUpdate(");
         902                 :
         903               0 :         (__logmsg).append("[TODO])\n");
         904               0 :         fputs((__logmsg).c_str(), __outf);
         905               0 :     }
         906                 : };
         907                 :
         908                 : class Msg_ClearUserPreference :
         909                 :     public IPC::Message
         910               0 : {
         911                 : private:
         912                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         913                 :     typedef mozilla::dom::StorageClone StorageClone;
         914                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         915                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         916                 :     typedef mozilla::ipc::Shmem Shmem;
         917                 :     typedef IPC::URI URI;
         918                 :     typedef IPC::Permission Permission;
         919                 :     typedef mozilla::null_t null_t;
         920                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         921                 :
         922                 : public:
         923                 :     enum {
         924                 :         ID = Msg_ClearUserPreference__ID
         925                 :     };
         926               0 :     Msg_ClearUserPreference() :
         927               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ClearUserPreference")
         928                 :     {
         929               0 :     }
         930                 :
         931                 :     void
         932               0 :     Log(
         933                 :             const std::string& __pfx,
         934                 :             FILE* __outf) const
         935                 :     {
         936               0 :         std::string __logmsg;
         937               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         938               0 :         (__logmsg).append(__pfx);
         939               0 :         (__logmsg).append("Msg_ClearUserPreference(");
         940                 :
         941               0 :         (__logmsg).append("[TODO])\n");
         942               0 :         fputs((__logmsg).c_str(), __outf);
         943               0 :     }
         944                 : };
         945                 :
         946                 : class Msg_NotifyAlertsObserver :
         947                 :     public IPC::Message
         948               0 : {
         949                 : private:
         950                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         951                 :     typedef mozilla::dom::StorageClone StorageClone;
         952                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         953                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         954                 :     typedef mozilla::ipc::Shmem Shmem;
         955                 :     typedef IPC::URI URI;
         956                 :     typedef IPC::Permission Permission;
         957                 :     typedef mozilla::null_t null_t;
         958                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         959                 :
         960                 : public:
         961                 :     enum {
         962                 :         ID = Msg_NotifyAlertsObserver__ID
         963                 :     };
         964               0 :     Msg_NotifyAlertsObserver() :
         965               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_NotifyAlertsObserver")
         966                 :     {
         967               0 :     }
         968                 :
         969                 :     void
         970               0 :     Log(
         971                 :             const std::string& __pfx,
         972                 :             FILE* __outf) const
         973                 :     {
         974               0 :         std::string __logmsg;
         975               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
         976               0 :         (__logmsg).append(__pfx);
         977               0 :         (__logmsg).append("Msg_NotifyAlertsObserver(");
         978                 :
         979               0 :         (__logmsg).append("[TODO])\n");
         980               0 :         fputs((__logmsg).c_str(), __outf);
         981               0 :     }
         982                 : };
         983                 :
         984                 : class Msg_GeolocationUpdate :
         985                 :     public IPC::Message
         986               0 : {
         987                 : private:
         988                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
         989                 :     typedef mozilla::dom::StorageClone StorageClone;
         990                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
         991                 :     typedef mozilla::dom::FontListEntry FontListEntry;
         992                 :     typedef mozilla::ipc::Shmem Shmem;
         993                 :     typedef IPC::URI URI;
         994                 :     typedef IPC::Permission Permission;
         995                 :     typedef mozilla::null_t null_t;
         996                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
         997                 :
         998                 : public:
         999                 :     enum {
        1000                 :         ID = Msg_GeolocationUpdate__ID
        1001                 :     };
        1002               0 :     Msg_GeolocationUpdate() :
        1003               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GeolocationUpdate")
        1004                 :     {
        1005               0 :     }
        1006                 :
        1007                 :     void
        1008               0 :     Log(
        1009                 :             const std::string& __pfx,
        1010                 :             FILE* __outf) const
        1011                 :     {
        1012               0 :         std::string __logmsg;
        1013               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1014               0 :         (__logmsg).append(__pfx);
        1015               0 :         (__logmsg).append("Msg_GeolocationUpdate(");
        1016                 :
        1017               0 :         (__logmsg).append("[TODO])\n");
        1018               0 :         fputs((__logmsg).c_str(), __outf);
        1019               0 :     }
        1020                 : };
        1021                 :
        1022                 : class Msg_AddPermission :
        1023                 :     public IPC::Message
        1024               0 : {
        1025                 : private:
        1026                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1027                 :     typedef mozilla::dom::StorageClone StorageClone;
        1028                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1029                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1030                 :     typedef mozilla::ipc::Shmem Shmem;
        1031                 :     typedef IPC::URI URI;
        1032                 :     typedef IPC::Permission Permission;
        1033                 :     typedef mozilla::null_t null_t;
        1034                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1035                 :
        1036                 : public:
        1037                 :     enum {
        1038                 :         ID = Msg_AddPermission__ID
        1039                 :     };
        1040               0 :     Msg_AddPermission() :
        1041               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_AddPermission")
        1042                 :     {
        1043               0 :     }
        1044                 :
        1045                 :     void
        1046               0 :     Log(
        1047                 :             const std::string& __pfx,
        1048                 :             FILE* __outf) const
        1049                 :     {
        1050               0 :         std::string __logmsg;
        1051               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1052               0 :         (__logmsg).append(__pfx);
        1053               0 :         (__logmsg).append("Msg_AddPermission(");
        1054                 :
        1055               0 :         (__logmsg).append("[TODO])\n");
        1056               0 :         fputs((__logmsg).c_str(), __outf);
        1057               0 :     }
        1058                 : };
        1059                 :
        1060                 : class Msg_DeviceMotionChanged :
        1061                 :     public IPC::Message
        1062               0 : {
        1063                 : private:
        1064                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1065                 :     typedef mozilla::dom::StorageClone StorageClone;
        1066                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1067                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1068                 :     typedef mozilla::ipc::Shmem Shmem;
        1069                 :     typedef IPC::URI URI;
        1070                 :     typedef IPC::Permission Permission;
        1071                 :     typedef mozilla::null_t null_t;
        1072                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1073                 :
        1074                 : public:
        1075                 :     enum {
        1076                 :         ID = Msg_DeviceMotionChanged__ID
        1077                 :     };
        1078               0 :     Msg_DeviceMotionChanged() :
        1079               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_DeviceMotionChanged")
        1080                 :     {
        1081               0 :     }
        1082                 :
        1083                 :     void
        1084               0 :     Log(
        1085                 :             const std::string& __pfx,
        1086                 :             FILE* __outf) const
        1087                 :     {
        1088               0 :         std::string __logmsg;
        1089               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1090               0 :         (__logmsg).append(__pfx);
        1091               0 :         (__logmsg).append("Msg_DeviceMotionChanged(");
        1092                 :
        1093               0 :         (__logmsg).append("[TODO])\n");
        1094               0 :         fputs((__logmsg).c_str(), __outf);
        1095               0 :     }
        1096                 : };
        1097                 :
        1098                 : class Msg_ScreenSizeChanged :
        1099                 :     public IPC::Message
        1100               0 : {
        1101                 : private:
        1102                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1103                 :     typedef mozilla::dom::StorageClone StorageClone;
        1104                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1105                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1106                 :     typedef mozilla::ipc::Shmem Shmem;
        1107                 :     typedef IPC::URI URI;
        1108                 :     typedef IPC::Permission Permission;
        1109                 :     typedef mozilla::null_t null_t;
        1110                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1111                 :
        1112                 : public:
        1113                 :     enum {
        1114                 :         ID = Msg_ScreenSizeChanged__ID
        1115                 :     };
        1116               0 :     Msg_ScreenSizeChanged() :
        1117               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ScreenSizeChanged")
        1118                 :     {
        1119               0 :     }
        1120                 :
        1121                 :     void
        1122               0 :     Log(
        1123                 :             const std::string& __pfx,
        1124                 :             FILE* __outf) const
        1125                 :     {
        1126               0 :         std::string __logmsg;
        1127               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1128               0 :         (__logmsg).append(__pfx);
        1129               0 :         (__logmsg).append("Msg_ScreenSizeChanged(");
        1130                 :
        1131               0 :         (__logmsg).append("[TODO])\n");
        1132               0 :         fputs((__logmsg).c_str(), __outf);
        1133               0 :     }
        1134                 : };
        1135                 :
        1136                 : class Msg_FlushMemory :
        1137                 :     public IPC::Message
        1138               0 : {
        1139                 : private:
        1140                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1141                 :     typedef mozilla::dom::StorageClone StorageClone;
        1142                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1143                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1144                 :     typedef mozilla::ipc::Shmem Shmem;
        1145                 :     typedef IPC::URI URI;
        1146                 :     typedef IPC::Permission Permission;
        1147                 :     typedef mozilla::null_t null_t;
        1148                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1149                 :
        1150                 : public:
        1151                 :     enum {
        1152                 :         ID = Msg_FlushMemory__ID
        1153                 :     };
        1154               0 :     Msg_FlushMemory() :
        1155               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_FlushMemory")
        1156                 :     {
        1157               0 :     }
        1158                 :
        1159                 :     void
        1160               0 :     Log(
        1161                 :             const std::string& __pfx,
        1162                 :             FILE* __outf) const
        1163                 :     {
        1164               0 :         std::string __logmsg;
        1165               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1166               0 :         (__logmsg).append(__pfx);
        1167               0 :         (__logmsg).append("Msg_FlushMemory(");
        1168                 :
        1169               0 :         (__logmsg).append("[TODO])\n");
        1170               0 :         fputs((__logmsg).c_str(), __outf);
        1171               0 :     }
        1172                 : };
        1173                 :
        1174                 : class Msg_GarbageCollect :
        1175                 :     public IPC::Message
        1176               0 : {
        1177                 : private:
        1178                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1179                 :     typedef mozilla::dom::StorageClone StorageClone;
        1180                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1181                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1182                 :     typedef mozilla::ipc::Shmem Shmem;
        1183                 :     typedef IPC::URI URI;
        1184                 :     typedef IPC::Permission Permission;
        1185                 :     typedef mozilla::null_t null_t;
        1186                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1187                 :
        1188                 : public:
        1189                 :     enum {
        1190                 :         ID = Msg_GarbageCollect__ID
        1191                 :     };
        1192               0 :     Msg_GarbageCollect() :
        1193               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GarbageCollect")
        1194                 :     {
        1195               0 :     }
        1196                 :
        1197                 :     void
        1198               0 :     Log(
        1199                 :             const std::string& __pfx,
        1200                 :             FILE* __outf) const
        1201                 :     {
        1202               0 :         std::string __logmsg;
        1203               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1204               0 :         (__logmsg).append(__pfx);
        1205               0 :         (__logmsg).append("Msg_GarbageCollect(");
        1206                 :
        1207               0 :         (__logmsg).append("[TODO])\n");
        1208               0 :         fputs((__logmsg).c_str(), __outf);
        1209               0 :     }
        1210                 : };
        1211                 :
        1212                 : class Msg_CycleCollect :
        1213                 :     public IPC::Message
        1214               0 : {
        1215                 : private:
        1216                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1217                 :     typedef mozilla::dom::StorageClone StorageClone;
        1218                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1219                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1220                 :     typedef mozilla::ipc::Shmem Shmem;
        1221                 :     typedef IPC::URI URI;
        1222                 :     typedef IPC::Permission Permission;
        1223                 :     typedef mozilla::null_t null_t;
        1224                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1225                 :
        1226                 : public:
        1227                 :     enum {
        1228                 :         ID = Msg_CycleCollect__ID
        1229                 :     };
        1230               0 :     Msg_CycleCollect() :
        1231               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_CycleCollect")
        1232                 :     {
        1233               0 :     }
        1234                 :
        1235                 :     void
        1236               0 :     Log(
        1237                 :             const std::string& __pfx,
        1238                 :             FILE* __outf) const
        1239                 :     {
        1240               0 :         std::string __logmsg;
        1241               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1242               0 :         (__logmsg).append(__pfx);
        1243               0 :         (__logmsg).append("Msg_CycleCollect(");
        1244                 :
        1245               0 :         (__logmsg).append("[TODO])\n");
        1246               0 :         fputs((__logmsg).c_str(), __outf);
        1247               0 :     }
        1248                 : };
        1249                 :
        1250                 : class Msg_ActivateA11y :
        1251                 :     public IPC::Message
        1252               0 : {
        1253                 : private:
        1254                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1255                 :     typedef mozilla::dom::StorageClone StorageClone;
        1256                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1257                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1258                 :     typedef mozilla::ipc::Shmem Shmem;
        1259                 :     typedef IPC::URI URI;
        1260                 :     typedef IPC::Permission Permission;
        1261                 :     typedef mozilla::null_t null_t;
        1262                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1263                 :
        1264                 : public:
        1265                 :     enum {
        1266                 :         ID = Msg_ActivateA11y__ID
        1267                 :     };
        1268               0 :     Msg_ActivateA11y() :
        1269               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ActivateA11y")
        1270                 :     {
        1271               0 :     }
        1272                 :
        1273                 :     void
        1274               0 :     Log(
        1275                 :             const std::string& __pfx,
        1276                 :             FILE* __outf) const
        1277                 :     {
        1278               0 :         std::string __logmsg;
        1279               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1280               0 :         (__logmsg).append(__pfx);
        1281               0 :         (__logmsg).append("Msg_ActivateA11y(");
        1282                 :
        1283               0 :         (__logmsg).append("[TODO])\n");
        1284               0 :         fputs((__logmsg).c_str(), __outf);
        1285               0 :     }
        1286                 : };
        1287                 :
        1288                 : class Msg_AppInfo :
        1289                 :     public IPC::Message
        1290               0 : {
        1291                 : private:
        1292                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1293                 :     typedef mozilla::dom::StorageClone StorageClone;
        1294                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1295                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1296                 :     typedef mozilla::ipc::Shmem Shmem;
        1297                 :     typedef IPC::URI URI;
        1298                 :     typedef IPC::Permission Permission;
        1299                 :     typedef mozilla::null_t null_t;
        1300                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1301                 :
        1302                 : public:
        1303                 :     enum {
        1304                 :         ID = Msg_AppInfo__ID
        1305                 :     };
        1306               0 :     Msg_AppInfo() :
        1307               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_AppInfo")
        1308                 :     {
        1309               0 :     }
        1310                 :
        1311                 :     void
        1312               0 :     Log(
        1313                 :             const std::string& __pfx,
        1314                 :             FILE* __outf) const
        1315                 :     {
        1316               0 :         std::string __logmsg;
        1317               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1318               0 :         (__logmsg).append(__pfx);
        1319               0 :         (__logmsg).append("Msg_AppInfo(");
        1320                 :
        1321               0 :         (__logmsg).append("[TODO])\n");
        1322               0 :         fputs((__logmsg).c_str(), __outf);
        1323               0 :     }
        1324                 : };
        1325                 :
        1326                 : class Msg_SetID :
        1327                 :     public IPC::Message
        1328               0 : {
        1329                 : private:
        1330                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1331                 :     typedef mozilla::dom::StorageClone StorageClone;
        1332                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1333                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1334                 :     typedef mozilla::ipc::Shmem Shmem;
        1335                 :     typedef IPC::URI URI;
        1336                 :     typedef IPC::Permission Permission;
        1337                 :     typedef mozilla::null_t null_t;
        1338                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1339                 :
        1340                 : public:
        1341                 :     enum {
        1342                 :         ID = Msg_SetID__ID
        1343                 :     };
        1344               0 :     Msg_SetID() :
        1345               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_SetID")
        1346                 :     {
        1347               0 :     }
        1348                 :
        1349                 :     void
        1350               0 :     Log(
        1351                 :             const std::string& __pfx,
        1352                 :             FILE* __outf) const
        1353                 :     {
        1354               0 :         std::string __logmsg;
        1355               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1356               0 :         (__logmsg).append(__pfx);
        1357               0 :         (__logmsg).append("Msg_SetID(");
        1358                 :
        1359               0 :         (__logmsg).append("[TODO])\n");
        1360               0 :         fputs((__logmsg).c_str(), __outf);
        1361               0 :     }
        1362                 : };
        1363                 :
        1364                 : class Msg_PAudioConstructor :
        1365                 :     public IPC::Message
        1366               0 : {
        1367                 : private:
        1368                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1369                 :     typedef mozilla::dom::StorageClone StorageClone;
        1370                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1371                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1372                 :     typedef mozilla::ipc::Shmem Shmem;
        1373                 :     typedef IPC::URI URI;
        1374                 :     typedef IPC::Permission Permission;
        1375                 :     typedef mozilla::null_t null_t;
        1376                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1377                 :
        1378                 : public:
        1379                 :     enum {
        1380                 :         ID = Msg_PAudioConstructor__ID
        1381                 :     };
        1382               0 :     Msg_PAudioConstructor() :
        1383               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PAudioConstructor")
        1384                 :     {
        1385               0 :     }
        1386                 :
        1387                 :     void
        1388               0 :     Log(
        1389                 :             const std::string& __pfx,
        1390                 :             FILE* __outf) const
        1391                 :     {
        1392               0 :         std::string __logmsg;
        1393               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1394               0 :         (__logmsg).append(__pfx);
        1395               0 :         (__logmsg).append("Msg_PAudioConstructor(");
        1396                 :
        1397               0 :         (__logmsg).append("[TODO])\n");
        1398               0 :         fputs((__logmsg).c_str(), __outf);
        1399               0 :     }
        1400                 : };
        1401                 :
        1402                 : class Reply_PAudioConstructor :
        1403                 :     public IPC::Message
        1404                 : {
        1405                 : private:
        1406                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1407                 :     typedef mozilla::dom::StorageClone StorageClone;
        1408                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1409                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1410                 :     typedef mozilla::ipc::Shmem Shmem;
        1411                 :     typedef IPC::URI URI;
        1412                 :     typedef IPC::Permission Permission;
        1413                 :     typedef mozilla::null_t null_t;
        1414                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1415                 :
        1416                 : public:
        1417                 :     enum {
        1418                 :         ID = Reply_PAudioConstructor__ID
        1419                 :     };
        1420                 :     Reply_PAudioConstructor() :
        1421                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PAudioConstructor")
        1422                 :     {
        1423                 :     }
        1424                 :
        1425                 :     void
        1426                 :     Log(
        1427                 :             const std::string& __pfx,
        1428                 :             FILE* __outf) const
        1429                 :     {
        1430                 :         std::string __logmsg;
        1431                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1432                 :         (__logmsg).append(__pfx);
        1433                 :         (__logmsg).append("Reply_PAudioConstructor(");
        1434                 :
        1435                 :         (__logmsg).append("[TODO])\n");
        1436                 :         fputs((__logmsg).c_str(), __outf);
        1437                 :     }
        1438                 : };
        1439                 :
        1440                 : class Msg_PCrashReporterConstructor :
        1441                 :     public IPC::Message
        1442               0 : {
        1443                 : private:
        1444                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1445                 :     typedef mozilla::dom::StorageClone StorageClone;
        1446                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1447                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1448                 :     typedef mozilla::ipc::Shmem Shmem;
        1449                 :     typedef IPC::URI URI;
        1450                 :     typedef IPC::Permission Permission;
        1451                 :     typedef mozilla::null_t null_t;
        1452                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1453                 :
        1454                 : public:
        1455                 :     enum {
        1456                 :         ID = Msg_PCrashReporterConstructor__ID
        1457                 :     };
        1458               0 :     Msg_PCrashReporterConstructor() :
        1459               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PCrashReporterConstructor")
        1460                 :     {
        1461               0 :     }
        1462                 :
        1463                 :     void
        1464               0 :     Log(
        1465                 :             const std::string& __pfx,
        1466                 :             FILE* __outf) const
        1467                 :     {
        1468               0 :         std::string __logmsg;
        1469               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1470               0 :         (__logmsg).append(__pfx);
        1471               0 :         (__logmsg).append("Msg_PCrashReporterConstructor(");
        1472                 :
        1473               0 :         (__logmsg).append("[TODO])\n");
        1474               0 :         fputs((__logmsg).c_str(), __outf);
        1475               0 :     }
        1476                 : };
        1477                 :
        1478                 : class Reply_PCrashReporterConstructor :
        1479                 :     public IPC::Message
        1480               0 : {
        1481                 : private:
        1482                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1483                 :     typedef mozilla::dom::StorageClone StorageClone;
        1484                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1485                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1486                 :     typedef mozilla::ipc::Shmem Shmem;
        1487                 :     typedef IPC::URI URI;
        1488                 :     typedef IPC::Permission Permission;
        1489                 :     typedef mozilla::null_t null_t;
        1490                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1491                 :
        1492                 : public:
        1493                 :     enum {
        1494                 :         ID = Reply_PCrashReporterConstructor__ID
        1495                 :     };
        1496               0 :     Reply_PCrashReporterConstructor() :
        1497               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PCrashReporterConstructor")
        1498                 :     {
        1499               0 :     }
        1500                 :
        1501                 :     void
        1502               0 :     Log(
        1503                 :             const std::string& __pfx,
        1504                 :             FILE* __outf) const
        1505                 :     {
        1506               0 :         std::string __logmsg;
        1507               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1508               0 :         (__logmsg).append(__pfx);
        1509               0 :         (__logmsg).append("Reply_PCrashReporterConstructor(");
        1510                 :
        1511               0 :         (__logmsg).append("[TODO])\n");
        1512               0 :         fputs((__logmsg).c_str(), __outf);
        1513               0 :     }
        1514                 : };
        1515                 :
        1516                 : class Msg_PHalConstructor :
        1517                 :     public IPC::Message
        1518               0 : {
        1519                 : private:
        1520                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1521                 :     typedef mozilla::dom::StorageClone StorageClone;
        1522                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1523                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1524                 :     typedef mozilla::ipc::Shmem Shmem;
        1525                 :     typedef IPC::URI URI;
        1526                 :     typedef IPC::Permission Permission;
        1527                 :     typedef mozilla::null_t null_t;
        1528                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1529                 :
        1530                 : public:
        1531                 :     enum {
        1532                 :         ID = Msg_PHalConstructor__ID
        1533                 :     };
        1534               0 :     Msg_PHalConstructor() :
        1535               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PHalConstructor")
        1536                 :     {
        1537               0 :     }
        1538                 :
        1539                 :     void
        1540               0 :     Log(
        1541                 :             const std::string& __pfx,
        1542                 :             FILE* __outf) const
        1543                 :     {
        1544               0 :         std::string __logmsg;
        1545               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1546               0 :         (__logmsg).append(__pfx);
        1547               0 :         (__logmsg).append("Msg_PHalConstructor(");
        1548                 :
        1549               0 :         (__logmsg).append("[TODO])\n");
        1550               0 :         fputs((__logmsg).c_str(), __outf);
        1551               0 :     }
        1552                 : };
        1553                 :
        1554                 : class Reply_PHalConstructor :
        1555                 :     public IPC::Message
        1556                 : {
        1557                 : private:
        1558                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1559                 :     typedef mozilla::dom::StorageClone StorageClone;
        1560                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1561                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1562                 :     typedef mozilla::ipc::Shmem Shmem;
        1563                 :     typedef IPC::URI URI;
        1564                 :     typedef IPC::Permission Permission;
        1565                 :     typedef mozilla::null_t null_t;
        1566                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1567                 :
        1568                 : public:
        1569                 :     enum {
        1570                 :         ID = Reply_PHalConstructor__ID
        1571                 :     };
        1572                 :     Reply_PHalConstructor() :
        1573                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PHalConstructor")
        1574                 :     {
        1575                 :     }
        1576                 :
        1577                 :     void
        1578                 :     Log(
        1579                 :             const std::string& __pfx,
        1580                 :             FILE* __outf) const
        1581                 :     {
        1582                 :         std::string __logmsg;
        1583                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1584                 :         (__logmsg).append(__pfx);
        1585                 :         (__logmsg).append("Reply_PHalConstructor(");
        1586                 :
        1587                 :         (__logmsg).append("[TODO])\n");
        1588                 :         fputs((__logmsg).c_str(), __outf);
        1589                 :     }
        1590                 : };
        1591                 :
        1592                 : class Msg_PNeckoConstructor :
        1593                 :     public IPC::Message
        1594               0 : {
        1595                 : private:
        1596                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1597                 :     typedef mozilla::dom::StorageClone StorageClone;
        1598                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1599                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1600                 :     typedef mozilla::ipc::Shmem Shmem;
        1601                 :     typedef IPC::URI URI;
        1602                 :     typedef IPC::Permission Permission;
        1603                 :     typedef mozilla::null_t null_t;
        1604                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1605                 :
        1606                 : public:
        1607                 :     enum {
        1608                 :         ID = Msg_PNeckoConstructor__ID
        1609                 :     };
        1610               0 :     Msg_PNeckoConstructor() :
        1611               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PNeckoConstructor")
        1612                 :     {
        1613               0 :     }
        1614                 :
        1615                 :     void
        1616               0 :     Log(
        1617                 :             const std::string& __pfx,
        1618                 :             FILE* __outf) const
        1619                 :     {
        1620               0 :         std::string __logmsg;
        1621               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1622               0 :         (__logmsg).append(__pfx);
        1623               0 :         (__logmsg).append("Msg_PNeckoConstructor(");
        1624                 :
        1625               0 :         (__logmsg).append("[TODO])\n");
        1626               0 :         fputs((__logmsg).c_str(), __outf);
        1627               0 :     }
        1628                 : };
        1629                 :
        1630                 : class Reply_PNeckoConstructor :
        1631                 :     public IPC::Message
        1632                 : {
        1633                 : private:
        1634                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1635                 :     typedef mozilla::dom::StorageClone StorageClone;
        1636                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1637                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1638                 :     typedef mozilla::ipc::Shmem Shmem;
        1639                 :     typedef IPC::URI URI;
        1640                 :     typedef IPC::Permission Permission;
        1641                 :     typedef mozilla::null_t null_t;
        1642                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1643                 :
        1644                 : public:
        1645                 :     enum {
        1646                 :         ID = Reply_PNeckoConstructor__ID
        1647                 :     };
        1648                 :     Reply_PNeckoConstructor() :
        1649                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PNeckoConstructor")
        1650                 :     {
        1651                 :     }
        1652                 :
        1653                 :     void
        1654                 :     Log(
        1655                 :             const std::string& __pfx,
        1656                 :             FILE* __outf) const
        1657                 :     {
        1658                 :         std::string __logmsg;
        1659                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1660                 :         (__logmsg).append(__pfx);
        1661                 :         (__logmsg).append("Reply_PNeckoConstructor(");
        1662                 :
        1663                 :         (__logmsg).append("[TODO])\n");
        1664                 :         fputs((__logmsg).c_str(), __outf);
        1665                 :     }
        1666                 : };
        1667                 :
        1668                 : class Msg_PSmsConstructor :
        1669                 :     public IPC::Message
        1670               0 : {
        1671                 : private:
        1672                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1673                 :     typedef mozilla::dom::StorageClone StorageClone;
        1674                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1675                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1676                 :     typedef mozilla::ipc::Shmem Shmem;
        1677                 :     typedef IPC::URI URI;
        1678                 :     typedef IPC::Permission Permission;
        1679                 :     typedef mozilla::null_t null_t;
        1680                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1681                 :
        1682                 : public:
        1683                 :     enum {
        1684                 :         ID = Msg_PSmsConstructor__ID
        1685                 :     };
        1686               0 :     Msg_PSmsConstructor() :
        1687               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PSmsConstructor")
        1688                 :     {
        1689               0 :     }
        1690                 :
        1691                 :     void
        1692               0 :     Log(
        1693                 :             const std::string& __pfx,
        1694                 :             FILE* __outf) const
        1695                 :     {
        1696               0 :         std::string __logmsg;
        1697               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1698               0 :         (__logmsg).append(__pfx);
        1699               0 :         (__logmsg).append("Msg_PSmsConstructor(");
        1700                 :
        1701               0 :         (__logmsg).append("[TODO])\n");
        1702               0 :         fputs((__logmsg).c_str(), __outf);
        1703               0 :     }
        1704                 : };
        1705                 :
        1706                 : class Reply_PSmsConstructor :
        1707                 :     public IPC::Message
        1708                 : {
        1709                 : private:
        1710                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1711                 :     typedef mozilla::dom::StorageClone StorageClone;
        1712                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1713                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1714                 :     typedef mozilla::ipc::Shmem Shmem;
        1715                 :     typedef IPC::URI URI;
        1716                 :     typedef IPC::Permission Permission;
        1717                 :     typedef mozilla::null_t null_t;
        1718                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1719                 :
        1720                 : public:
        1721                 :     enum {
        1722                 :         ID = Reply_PSmsConstructor__ID
        1723                 :     };
        1724                 :     Reply_PSmsConstructor() :
        1725                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PSmsConstructor")
        1726                 :     {
        1727                 :     }
        1728                 :
        1729                 :     void
        1730                 :     Log(
        1731                 :             const std::string& __pfx,
        1732                 :             FILE* __outf) const
        1733                 :     {
        1734                 :         std::string __logmsg;
        1735                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1736                 :         (__logmsg).append(__pfx);
        1737                 :         (__logmsg).append("Reply_PSmsConstructor(");
        1738                 :
        1739                 :         (__logmsg).append("[TODO])\n");
        1740                 :         fputs((__logmsg).c_str(), __outf);
        1741                 :     }
        1742                 : };
        1743                 :
        1744                 : class Msg_PStorageConstructor :
        1745                 :     public IPC::Message
        1746               0 : {
        1747                 : private:
        1748                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1749                 :     typedef mozilla::dom::StorageClone StorageClone;
        1750                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1751                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1752                 :     typedef mozilla::ipc::Shmem Shmem;
        1753                 :     typedef IPC::URI URI;
        1754                 :     typedef IPC::Permission Permission;
        1755                 :     typedef mozilla::null_t null_t;
        1756                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1757                 :
        1758                 : public:
        1759                 :     enum {
        1760                 :         ID = Msg_PStorageConstructor__ID
        1761                 :     };
        1762               0 :     Msg_PStorageConstructor() :
        1763               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PStorageConstructor")
        1764                 :     {
        1765               0 :     }
        1766                 :
        1767                 :     void
        1768               0 :     Log(
        1769                 :             const std::string& __pfx,
        1770                 :             FILE* __outf) const
        1771                 :     {
        1772               0 :         std::string __logmsg;
        1773               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1774               0 :         (__logmsg).append(__pfx);
        1775               0 :         (__logmsg).append("Msg_PStorageConstructor(");
        1776                 :
        1777               0 :         (__logmsg).append("[TODO])\n");
        1778               0 :         fputs((__logmsg).c_str(), __outf);
        1779               0 :     }
        1780                 : };
        1781                 :
        1782                 : class Reply_PStorageConstructor :
        1783                 :     public IPC::Message
        1784                 : {
        1785                 : private:
        1786                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1787                 :     typedef mozilla::dom::StorageClone StorageClone;
        1788                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1789                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1790                 :     typedef mozilla::ipc::Shmem Shmem;
        1791                 :     typedef IPC::URI URI;
        1792                 :     typedef IPC::Permission Permission;
        1793                 :     typedef mozilla::null_t null_t;
        1794                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1795                 :
        1796                 : public:
        1797                 :     enum {
        1798                 :         ID = Reply_PStorageConstructor__ID
        1799                 :     };
        1800                 :     Reply_PStorageConstructor() :
        1801                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PStorageConstructor")
        1802                 :     {
        1803                 :     }
        1804                 :
        1805                 :     void
        1806                 :     Log(
        1807                 :             const std::string& __pfx,
        1808                 :             FILE* __outf) const
        1809                 :     {
        1810                 :         std::string __logmsg;
        1811                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1812                 :         (__logmsg).append(__pfx);
        1813                 :         (__logmsg).append("Reply_PStorageConstructor(");
        1814                 :
        1815                 :         (__logmsg).append("[TODO])\n");
        1816                 :         fputs((__logmsg).c_str(), __outf);
        1817                 :     }
        1818                 : };
        1819                 :
        1820                 : class Msg_StartVisitedQuery :
        1821                 :     public IPC::Message
        1822               0 : {
        1823                 : private:
        1824                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1825                 :     typedef mozilla::dom::StorageClone StorageClone;
        1826                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1827                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1828                 :     typedef mozilla::ipc::Shmem Shmem;
        1829                 :     typedef IPC::URI URI;
        1830                 :     typedef IPC::Permission Permission;
        1831                 :     typedef mozilla::null_t null_t;
        1832                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1833                 :
        1834                 : public:
        1835                 :     enum {
        1836                 :         ID = Msg_StartVisitedQuery__ID
        1837                 :     };
        1838               0 :     Msg_StartVisitedQuery() :
        1839               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_StartVisitedQuery")
        1840                 :     {
        1841               0 :     }
        1842                 :
        1843                 :     void
        1844               0 :     Log(
        1845                 :             const std::string& __pfx,
        1846                 :             FILE* __outf) const
        1847                 :     {
        1848               0 :         std::string __logmsg;
        1849               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1850               0 :         (__logmsg).append(__pfx);
        1851               0 :         (__logmsg).append("Msg_StartVisitedQuery(");
        1852                 :
        1853               0 :         (__logmsg).append("[TODO])\n");
        1854               0 :         fputs((__logmsg).c_str(), __outf);
        1855               0 :     }
        1856                 : };
        1857                 :
        1858                 : class Msg_VisitURI :
        1859                 :     public IPC::Message
        1860               0 : {
        1861                 : private:
        1862                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1863                 :     typedef mozilla::dom::StorageClone StorageClone;
        1864                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1865                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1866                 :     typedef mozilla::ipc::Shmem Shmem;
        1867                 :     typedef IPC::URI URI;
        1868                 :     typedef IPC::Permission Permission;
        1869                 :     typedef mozilla::null_t null_t;
        1870                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1871                 :
        1872                 : public:
        1873                 :     enum {
        1874                 :         ID = Msg_VisitURI__ID
        1875                 :     };
        1876               0 :     Msg_VisitURI() :
        1877               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_VisitURI")
        1878                 :     {
        1879               0 :     }
        1880                 :
        1881                 :     void
        1882               0 :     Log(
        1883                 :             const std::string& __pfx,
        1884                 :             FILE* __outf) const
        1885                 :     {
        1886               0 :         std::string __logmsg;
        1887               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1888               0 :         (__logmsg).append(__pfx);
        1889               0 :         (__logmsg).append("Msg_VisitURI(");
        1890                 :
        1891               0 :         (__logmsg).append("[TODO])\n");
        1892               0 :         fputs((__logmsg).c_str(), __outf);
        1893               0 :     }
        1894                 : };
        1895                 :
        1896                 : class Msg_SetURITitle :
        1897                 :     public IPC::Message
        1898               0 : {
        1899                 : private:
        1900                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1901                 :     typedef mozilla::dom::StorageClone StorageClone;
        1902                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1903                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1904                 :     typedef mozilla::ipc::Shmem Shmem;
        1905                 :     typedef IPC::URI URI;
        1906                 :     typedef IPC::Permission Permission;
        1907                 :     typedef mozilla::null_t null_t;
        1908                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1909                 :
        1910                 : public:
        1911                 :     enum {
        1912                 :         ID = Msg_SetURITitle__ID
        1913                 :     };
        1914               0 :     Msg_SetURITitle() :
        1915               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_SetURITitle")
        1916                 :     {
        1917               0 :     }
        1918                 :
        1919                 :     void
        1920               0 :     Log(
        1921                 :             const std::string& __pfx,
        1922                 :             FILE* __outf) const
        1923                 :     {
        1924               0 :         std::string __logmsg;
        1925               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1926               0 :         (__logmsg).append(__pfx);
        1927               0 :         (__logmsg).append("Msg_SetURITitle(");
        1928                 :
        1929               0 :         (__logmsg).append("[TODO])\n");
        1930               0 :         fputs((__logmsg).c_str(), __outf);
        1931               0 :     }
        1932                 : };
        1933                 :
        1934                 : class Msg_ShowFilePicker :
        1935                 :     public IPC::Message
        1936               0 : {
        1937                 : private:
        1938                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1939                 :     typedef mozilla::dom::StorageClone StorageClone;
        1940                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1941                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1942                 :     typedef mozilla::ipc::Shmem Shmem;
        1943                 :     typedef IPC::URI URI;
        1944                 :     typedef IPC::Permission Permission;
        1945                 :     typedef mozilla::null_t null_t;
        1946                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1947                 :
        1948                 : public:
        1949                 :     enum {
        1950                 :         ID = Msg_ShowFilePicker__ID
        1951                 :     };
        1952               0 :     Msg_ShowFilePicker() :
        1953               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ShowFilePicker")
        1954                 :     {
        1955               0 :     }
        1956                 :
        1957                 :     void
        1958               0 :     Log(
        1959                 :             const std::string& __pfx,
        1960                 :             FILE* __outf) const
        1961                 :     {
        1962               0 :         std::string __logmsg;
        1963               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        1964               0 :         (__logmsg).append(__pfx);
        1965               0 :         (__logmsg).append("Msg_ShowFilePicker(");
        1966                 :
        1967               0 :         (__logmsg).append("[TODO])\n");
        1968               0 :         fputs((__logmsg).c_str(), __outf);
        1969               0 :     }
        1970                 : };
        1971                 :
        1972                 : class Reply_ShowFilePicker :
        1973                 :     public IPC::Message
        1974               0 : {
        1975                 : private:
        1976                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        1977                 :     typedef mozilla::dom::StorageClone StorageClone;
        1978                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        1979                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        1980                 :     typedef mozilla::ipc::Shmem Shmem;
        1981                 :     typedef IPC::URI URI;
        1982                 :     typedef IPC::Permission Permission;
        1983                 :     typedef mozilla::null_t null_t;
        1984                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        1985                 :
        1986                 : public:
        1987                 :     enum {
        1988                 :         ID = Reply_ShowFilePicker__ID
        1989                 :     };
        1990               0 :     Reply_ShowFilePicker() :
        1991               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_ShowFilePicker")
        1992                 :     {
        1993               0 :     }
        1994                 :
        1995                 :     void
        1996               0 :     Log(
        1997                 :             const std::string& __pfx,
        1998                 :             FILE* __outf) const
        1999                 :     {
        2000               0 :         std::string __logmsg;
        2001               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2002               0 :         (__logmsg).append(__pfx);
        2003               0 :         (__logmsg).append("Reply_ShowFilePicker(");
        2004                 :
        2005               0 :         (__logmsg).append("[TODO])\n");
        2006               0 :         fputs((__logmsg).c_str(), __outf);
        2007               0 :     }
        2008                 : };
        2009                 :
        2010                 : class Msg_LoadURIExternal :
        2011                 :     public IPC::Message
        2012               0 : {
        2013                 : private:
        2014                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2015                 :     typedef mozilla::dom::StorageClone StorageClone;
        2016                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2017                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2018                 :     typedef mozilla::ipc::Shmem Shmem;
        2019                 :     typedef IPC::URI URI;
        2020                 :     typedef IPC::Permission Permission;
        2021                 :     typedef mozilla::null_t null_t;
        2022                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2023                 :
        2024                 : public:
        2025                 :     enum {
        2026                 :         ID = Msg_LoadURIExternal__ID
        2027                 :     };
        2028               0 :     Msg_LoadURIExternal() :
        2029               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_LoadURIExternal")
        2030                 :     {
        2031               0 :     }
        2032                 :
        2033                 :     void
        2034               0 :     Log(
        2035                 :             const std::string& __pfx,
        2036                 :             FILE* __outf) const
        2037                 :     {
        2038               0 :         std::string __logmsg;
        2039               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2040               0 :         (__logmsg).append(__pfx);
        2041               0 :         (__logmsg).append("Msg_LoadURIExternal(");
        2042                 :
        2043               0 :         (__logmsg).append("[TODO])\n");
        2044               0 :         fputs((__logmsg).c_str(), __outf);
        2045               0 :     }
        2046                 : };
        2047                 :
        2048                 : class Msg_ReadPrefsArray :
        2049                 :     public IPC::Message
        2050               0 : {
        2051                 : private:
        2052                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2053                 :     typedef mozilla::dom::StorageClone StorageClone;
        2054                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2055                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2056                 :     typedef mozilla::ipc::Shmem Shmem;
        2057                 :     typedef IPC::URI URI;
        2058                 :     typedef IPC::Permission Permission;
        2059                 :     typedef mozilla::null_t null_t;
        2060                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2061                 :
        2062                 : public:
        2063                 :     enum {
        2064                 :         ID = Msg_ReadPrefsArray__ID
        2065                 :     };
        2066               0 :     Msg_ReadPrefsArray() :
        2067               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ReadPrefsArray")
        2068                 :     {
        2069               0 :     }
        2070                 :
        2071                 :     void
        2072               0 :     Log(
        2073                 :             const std::string& __pfx,
        2074                 :             FILE* __outf) const
        2075                 :     {
        2076               0 :         std::string __logmsg;
        2077               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2078               0 :         (__logmsg).append(__pfx);
        2079               0 :         (__logmsg).append("Msg_ReadPrefsArray(");
        2080                 :
        2081               0 :         (__logmsg).append("[TODO])\n");
        2082               0 :         fputs((__logmsg).c_str(), __outf);
        2083               0 :     }
        2084                 : };
        2085                 :
        2086                 : class Reply_ReadPrefsArray :
        2087                 :     public IPC::Message
        2088               0 : {
        2089                 : private:
        2090                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2091                 :     typedef mozilla::dom::StorageClone StorageClone;
        2092                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2093                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2094                 :     typedef mozilla::ipc::Shmem Shmem;
        2095                 :     typedef IPC::URI URI;
        2096                 :     typedef IPC::Permission Permission;
        2097                 :     typedef mozilla::null_t null_t;
        2098                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2099                 :
        2100                 : public:
        2101                 :     enum {
        2102                 :         ID = Reply_ReadPrefsArray__ID
        2103                 :     };
        2104               0 :     Reply_ReadPrefsArray() :
        2105               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_ReadPrefsArray")
        2106                 :     {
        2107               0 :     }
        2108                 :
        2109                 :     void
        2110               0 :     Log(
        2111                 :             const std::string& __pfx,
        2112                 :             FILE* __outf) const
        2113                 :     {
        2114               0 :         std::string __logmsg;
        2115               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2116               0 :         (__logmsg).append(__pfx);
        2117               0 :         (__logmsg).append("Reply_ReadPrefsArray(");
        2118                 :
        2119               0 :         (__logmsg).append("[TODO])\n");
        2120               0 :         fputs((__logmsg).c_str(), __outf);
        2121               0 :     }
        2122                 : };
        2123                 :
        2124                 : class Msg_ReadFontList :
        2125                 :     public IPC::Message
        2126               0 : {
        2127                 : private:
        2128                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2129                 :     typedef mozilla::dom::StorageClone StorageClone;
        2130                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2131                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2132                 :     typedef mozilla::ipc::Shmem Shmem;
        2133                 :     typedef IPC::URI URI;
        2134                 :     typedef IPC::Permission Permission;
        2135                 :     typedef mozilla::null_t null_t;
        2136                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2137                 :
        2138                 : public:
        2139                 :     enum {
        2140                 :         ID = Msg_ReadFontList__ID
        2141                 :     };
        2142               0 :     Msg_ReadFontList() :
        2143               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ReadFontList")
        2144                 :     {
        2145               0 :     }
        2146                 :
        2147                 :     void
        2148               0 :     Log(
        2149                 :             const std::string& __pfx,
        2150                 :             FILE* __outf) const
        2151                 :     {
        2152               0 :         std::string __logmsg;
        2153               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2154               0 :         (__logmsg).append(__pfx);
        2155               0 :         (__logmsg).append("Msg_ReadFontList(");
        2156                 :
        2157               0 :         (__logmsg).append("[TODO])\n");
        2158               0 :         fputs((__logmsg).c_str(), __outf);
        2159               0 :     }
        2160                 : };
        2161                 :
        2162                 : class Reply_ReadFontList :
        2163                 :     public IPC::Message
        2164               0 : {
        2165                 : private:
        2166                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2167                 :     typedef mozilla::dom::StorageClone StorageClone;
        2168                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2169                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2170                 :     typedef mozilla::ipc::Shmem Shmem;
        2171                 :     typedef IPC::URI URI;
        2172                 :     typedef IPC::Permission Permission;
        2173                 :     typedef mozilla::null_t null_t;
        2174                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2175                 :
        2176                 : public:
        2177                 :     enum {
        2178                 :         ID = Reply_ReadFontList__ID
        2179                 :     };
        2180               0 :     Reply_ReadFontList() :
        2181               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_ReadFontList")
        2182                 :     {
        2183               0 :     }
        2184                 :
        2185                 :     void
        2186               0 :     Log(
        2187                 :             const std::string& __pfx,
        2188                 :             FILE* __outf) const
        2189                 :     {
        2190               0 :         std::string __logmsg;
        2191               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2192               0 :         (__logmsg).append(__pfx);
        2193               0 :         (__logmsg).append("Reply_ReadFontList(");
        2194                 :
        2195               0 :         (__logmsg).append("[TODO])\n");
        2196               0 :         fputs((__logmsg).c_str(), __outf);
        2197               0 :     }
        2198                 : };
        2199                 :
        2200                 : class Msg_SyncMessage :
        2201                 :     public IPC::Message
        2202               0 : {
        2203                 : private:
        2204                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2205                 :     typedef mozilla::dom::StorageClone StorageClone;
        2206                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2207                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2208                 :     typedef mozilla::ipc::Shmem Shmem;
        2209                 :     typedef IPC::URI URI;
        2210                 :     typedef IPC::Permission Permission;
        2211                 :     typedef mozilla::null_t null_t;
        2212                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2213                 :
        2214                 : public:
        2215                 :     enum {
        2216                 :         ID = Msg_SyncMessage__ID
        2217                 :     };
        2218               0 :     Msg_SyncMessage() :
        2219               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_SyncMessage")
        2220                 :     {
        2221               0 :     }
        2222                 :
        2223                 :     void
        2224               0 :     Log(
        2225                 :             const std::string& __pfx,
        2226                 :             FILE* __outf) const
        2227                 :     {
        2228               0 :         std::string __logmsg;
        2229               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2230               0 :         (__logmsg).append(__pfx);
        2231               0 :         (__logmsg).append("Msg_SyncMessage(");
        2232                 :
        2233               0 :         (__logmsg).append("[TODO])\n");
        2234               0 :         fputs((__logmsg).c_str(), __outf);
        2235               0 :     }
        2236                 : };
        2237                 :
        2238                 : class Reply_SyncMessage :
        2239                 :     public IPC::Message
        2240               0 : {
        2241                 : private:
        2242                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2243                 :     typedef mozilla::dom::StorageClone StorageClone;
        2244                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2245                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2246                 :     typedef mozilla::ipc::Shmem Shmem;
        2247                 :     typedef IPC::URI URI;
        2248                 :     typedef IPC::Permission Permission;
        2249                 :     typedef mozilla::null_t null_t;
        2250                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2251                 :
        2252                 : public:
        2253                 :     enum {
        2254                 :         ID = Reply_SyncMessage__ID
        2255                 :     };
        2256               0 :     Reply_SyncMessage() :
        2257               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_SyncMessage")
        2258                 :     {
        2259               0 :     }
        2260                 :
        2261                 :     void
        2262               0 :     Log(
        2263                 :             const std::string& __pfx,
        2264                 :             FILE* __outf) const
        2265                 :     {
        2266               0 :         std::string __logmsg;
        2267               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2268               0 :         (__logmsg).append(__pfx);
        2269               0 :         (__logmsg).append("Reply_SyncMessage(");
        2270                 :
        2271               0 :         (__logmsg).append("[TODO])\n");
        2272               0 :         fputs((__logmsg).c_str(), __outf);
        2273               0 :     }
        2274                 : };
        2275                 :
        2276                 : class Msg_ShowAlertNotification :
        2277                 :     public IPC::Message
        2278               0 : {
        2279                 : private:
        2280                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2281                 :     typedef mozilla::dom::StorageClone StorageClone;
        2282                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2283                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2284                 :     typedef mozilla::ipc::Shmem Shmem;
        2285                 :     typedef IPC::URI URI;
        2286                 :     typedef IPC::Permission Permission;
        2287                 :     typedef mozilla::null_t null_t;
        2288                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2289                 :
        2290                 : public:
        2291                 :     enum {
        2292                 :         ID = Msg_ShowAlertNotification__ID
        2293                 :     };
        2294               0 :     Msg_ShowAlertNotification() :
        2295               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ShowAlertNotification")
        2296                 :     {
        2297               0 :     }
        2298                 :
        2299                 :     void
        2300               0 :     Log(
        2301                 :             const std::string& __pfx,
        2302                 :             FILE* __outf) const
        2303                 :     {
        2304               0 :         std::string __logmsg;
        2305               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2306               0 :         (__logmsg).append(__pfx);
        2307               0 :         (__logmsg).append("Msg_ShowAlertNotification(");
        2308                 :
        2309               0 :         (__logmsg).append("[TODO])\n");
        2310               0 :         fputs((__logmsg).c_str(), __outf);
        2311               0 :     }
        2312                 : };
        2313                 :
        2314                 : class Msg_PExternalHelperAppConstructor :
        2315                 :     public IPC::Message
        2316               0 : {
        2317                 : private:
        2318                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2319                 :     typedef mozilla::dom::StorageClone StorageClone;
        2320                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2321                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2322                 :     typedef mozilla::ipc::Shmem Shmem;
        2323                 :     typedef IPC::URI URI;
        2324                 :     typedef IPC::Permission Permission;
        2325                 :     typedef mozilla::null_t null_t;
        2326                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2327                 :
        2328                 : public:
        2329                 :     enum {
        2330                 :         ID = Msg_PExternalHelperAppConstructor__ID
        2331                 :     };
        2332               0 :     Msg_PExternalHelperAppConstructor() :
        2333               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_PExternalHelperAppConstructor")
        2334                 :     {
        2335               0 :     }
        2336                 :
        2337                 :     void
        2338               0 :     Log(
        2339                 :             const std::string& __pfx,
        2340                 :             FILE* __outf) const
        2341                 :     {
        2342               0 :         std::string __logmsg;
        2343               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2344               0 :         (__logmsg).append(__pfx);
        2345               0 :         (__logmsg).append("Msg_PExternalHelperAppConstructor(");
        2346                 :
        2347               0 :         (__logmsg).append("[TODO])\n");
        2348               0 :         fputs((__logmsg).c_str(), __outf);
        2349               0 :     }
        2350                 : };
        2351                 :
        2352                 : class Reply_PExternalHelperAppConstructor :
        2353                 :     public IPC::Message
        2354                 : {
        2355                 : private:
        2356                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2357                 :     typedef mozilla::dom::StorageClone StorageClone;
        2358                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2359                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2360                 :     typedef mozilla::ipc::Shmem Shmem;
        2361                 :     typedef IPC::URI URI;
        2362                 :     typedef IPC::Permission Permission;
        2363                 :     typedef mozilla::null_t null_t;
        2364                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2365                 :
        2366                 : public:
        2367                 :     enum {
        2368                 :         ID = Reply_PExternalHelperAppConstructor__ID
        2369                 :     };
        2370                 :     Reply_PExternalHelperAppConstructor() :
        2371                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_PExternalHelperAppConstructor")
        2372                 :     {
        2373                 :     }
        2374                 :
        2375                 :     void
        2376                 :     Log(
        2377                 :             const std::string& __pfx,
        2378                 :             FILE* __outf) const
        2379                 :     {
        2380                 :         std::string __logmsg;
        2381                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2382                 :         (__logmsg).append(__pfx);
        2383                 :         (__logmsg).append("Reply_PExternalHelperAppConstructor(");
        2384                 :
        2385                 :         (__logmsg).append("[TODO])\n");
        2386                 :         fputs((__logmsg).c_str(), __outf);
        2387                 :     }
        2388                 : };
        2389                 :
        2390                 : class Msg_AddGeolocationListener :
        2391                 :     public IPC::Message
        2392               0 : {
        2393                 : private:
        2394                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2395                 :     typedef mozilla::dom::StorageClone StorageClone;
        2396                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2397                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2398                 :     typedef mozilla::ipc::Shmem Shmem;
        2399                 :     typedef IPC::URI URI;
        2400                 :     typedef IPC::Permission Permission;
        2401                 :     typedef mozilla::null_t null_t;
        2402                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2403                 :
        2404                 : public:
        2405                 :     enum {
        2406                 :         ID = Msg_AddGeolocationListener__ID
        2407                 :     };
        2408               0 :     Msg_AddGeolocationListener() :
        2409               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_AddGeolocationListener")
        2410                 :     {
        2411               0 :     }
        2412                 :
        2413                 :     void
        2414               0 :     Log(
        2415                 :             const std::string& __pfx,
        2416                 :             FILE* __outf) const
        2417                 :     {
        2418               0 :         std::string __logmsg;
        2419               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2420               0 :         (__logmsg).append(__pfx);
        2421               0 :         (__logmsg).append("Msg_AddGeolocationListener(");
        2422                 :
        2423               0 :         (__logmsg).append("[TODO])\n");
        2424               0 :         fputs((__logmsg).c_str(), __outf);
        2425               0 :     }
        2426                 : };
        2427                 :
        2428                 : class Msg_RemoveGeolocationListener :
        2429                 :     public IPC::Message
        2430               0 : {
        2431                 : private:
        2432                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2433                 :     typedef mozilla::dom::StorageClone StorageClone;
        2434                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2435                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2436                 :     typedef mozilla::ipc::Shmem Shmem;
        2437                 :     typedef IPC::URI URI;
        2438                 :     typedef IPC::Permission Permission;
        2439                 :     typedef mozilla::null_t null_t;
        2440                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2441                 :
        2442                 : public:
        2443                 :     enum {
        2444                 :         ID = Msg_RemoveGeolocationListener__ID
        2445                 :     };
        2446               0 :     Msg_RemoveGeolocationListener() :
        2447               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_RemoveGeolocationListener")
        2448                 :     {
        2449               0 :     }
        2450                 :
        2451                 :     void
        2452               0 :     Log(
        2453                 :             const std::string& __pfx,
        2454                 :             FILE* __outf) const
        2455                 :     {
        2456               0 :         std::string __logmsg;
        2457               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2458               0 :         (__logmsg).append(__pfx);
        2459               0 :         (__logmsg).append("Msg_RemoveGeolocationListener(");
        2460                 :
        2461               0 :         (__logmsg).append("[TODO])\n");
        2462               0 :         fputs((__logmsg).c_str(), __outf);
        2463               0 :     }
        2464                 : };
        2465                 :
        2466                 : class Msg_AddDeviceMotionListener :
        2467                 :     public IPC::Message
        2468               0 : {
        2469                 : private:
        2470                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2471                 :     typedef mozilla::dom::StorageClone StorageClone;
        2472                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2473                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2474                 :     typedef mozilla::ipc::Shmem Shmem;
        2475                 :     typedef IPC::URI URI;
        2476                 :     typedef IPC::Permission Permission;
        2477                 :     typedef mozilla::null_t null_t;
        2478                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2479                 :
        2480                 : public:
        2481                 :     enum {
        2482                 :         ID = Msg_AddDeviceMotionListener__ID
        2483                 :     };
        2484               0 :     Msg_AddDeviceMotionListener() :
        2485               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_AddDeviceMotionListener")
        2486                 :     {
        2487               0 :     }
        2488                 :
        2489                 :     void
        2490               0 :     Log(
        2491                 :             const std::string& __pfx,
        2492                 :             FILE* __outf) const
        2493                 :     {
        2494               0 :         std::string __logmsg;
        2495               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2496               0 :         (__logmsg).append(__pfx);
        2497               0 :         (__logmsg).append("Msg_AddDeviceMotionListener(");
        2498                 :
        2499               0 :         (__logmsg).append("[TODO])\n");
        2500               0 :         fputs((__logmsg).c_str(), __outf);
        2501               0 :     }
        2502                 : };
        2503                 :
        2504                 : class Msg_RemoveDeviceMotionListener :
        2505                 :     public IPC::Message
        2506               0 : {
        2507                 : private:
        2508                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2509                 :     typedef mozilla::dom::StorageClone StorageClone;
        2510                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2511                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2512                 :     typedef mozilla::ipc::Shmem Shmem;
        2513                 :     typedef IPC::URI URI;
        2514                 :     typedef IPC::Permission Permission;
        2515                 :     typedef mozilla::null_t null_t;
        2516                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2517                 :
        2518                 : public:
        2519                 :     enum {
        2520                 :         ID = Msg_RemoveDeviceMotionListener__ID
        2521                 :     };
        2522               0 :     Msg_RemoveDeviceMotionListener() :
        2523               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_RemoveDeviceMotionListener")
        2524                 :     {
        2525               0 :     }
        2526                 :
        2527                 :     void
        2528               0 :     Log(
        2529                 :             const std::string& __pfx,
        2530                 :             FILE* __outf) const
        2531                 :     {
        2532               0 :         std::string __logmsg;
        2533               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2534               0 :         (__logmsg).append(__pfx);
        2535               0 :         (__logmsg).append("Msg_RemoveDeviceMotionListener(");
        2536                 :
        2537               0 :         (__logmsg).append("[TODO])\n");
        2538               0 :         fputs((__logmsg).c_str(), __outf);
        2539               0 :     }
        2540                 : };
        2541                 :
        2542                 : class Msg_ConsoleMessage :
        2543                 :     public IPC::Message
        2544               0 : {
        2545                 : private:
        2546                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2547                 :     typedef mozilla::dom::StorageClone StorageClone;
        2548                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2549                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2550                 :     typedef mozilla::ipc::Shmem Shmem;
        2551                 :     typedef IPC::URI URI;
        2552                 :     typedef IPC::Permission Permission;
        2553                 :     typedef mozilla::null_t null_t;
        2554                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2555                 :
        2556                 : public:
        2557                 :     enum {
        2558                 :         ID = Msg_ConsoleMessage__ID
        2559                 :     };
        2560               0 :     Msg_ConsoleMessage() :
        2561               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ConsoleMessage")
        2562                 :     {
        2563               0 :     }
        2564                 :
        2565                 :     void
        2566               0 :     Log(
        2567                 :             const std::string& __pfx,
        2568                 :             FILE* __outf) const
        2569                 :     {
        2570               0 :         std::string __logmsg;
        2571               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2572               0 :         (__logmsg).append(__pfx);
        2573               0 :         (__logmsg).append("Msg_ConsoleMessage(");
        2574                 :
        2575               0 :         (__logmsg).append("[TODO])\n");
        2576               0 :         fputs((__logmsg).c_str(), __outf);
        2577               0 :     }
        2578                 : };
        2579                 :
        2580                 : class Msg_ScriptError :
        2581                 :     public IPC::Message
        2582               0 : {
        2583                 : private:
        2584                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2585                 :     typedef mozilla::dom::StorageClone StorageClone;
        2586                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2587                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2588                 :     typedef mozilla::ipc::Shmem Shmem;
        2589                 :     typedef IPC::URI URI;
        2590                 :     typedef IPC::Permission Permission;
        2591                 :     typedef mozilla::null_t null_t;
        2592                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2593                 :
        2594                 : public:
        2595                 :     enum {
        2596                 :         ID = Msg_ScriptError__ID
        2597                 :     };
        2598               0 :     Msg_ScriptError() :
        2599               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ScriptError")
        2600                 :     {
        2601               0 :     }
        2602                 :
        2603                 :     void
        2604               0 :     Log(
        2605                 :             const std::string& __pfx,
        2606                 :             FILE* __outf) const
        2607                 :     {
        2608               0 :         std::string __logmsg;
        2609               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2610               0 :         (__logmsg).append(__pfx);
        2611               0 :         (__logmsg).append("Msg_ScriptError(");
        2612                 :
        2613               0 :         (__logmsg).append("[TODO])\n");
        2614               0 :         fputs((__logmsg).c_str(), __outf);
        2615               0 :     }
        2616                 : };
        2617                 :
        2618                 : class Msg_ReadPermissions :
        2619                 :     public IPC::Message
        2620               0 : {
        2621                 : private:
        2622                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2623                 :     typedef mozilla::dom::StorageClone StorageClone;
        2624                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2625                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2626                 :     typedef mozilla::ipc::Shmem Shmem;
        2627                 :     typedef IPC::URI URI;
        2628                 :     typedef IPC::Permission Permission;
        2629                 :     typedef mozilla::null_t null_t;
        2630                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2631                 :
        2632                 : public:
        2633                 :     enum {
        2634                 :         ID = Msg_ReadPermissions__ID
        2635                 :     };
        2636               0 :     Msg_ReadPermissions() :
        2637               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ReadPermissions")
        2638                 :     {
        2639               0 :     }
        2640                 :
        2641                 :     void
        2642               0 :     Log(
        2643                 :             const std::string& __pfx,
        2644                 :             FILE* __outf) const
        2645                 :     {
        2646               0 :         std::string __logmsg;
        2647               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2648               0 :         (__logmsg).append(__pfx);
        2649               0 :         (__logmsg).append("Msg_ReadPermissions(");
        2650                 :
        2651               0 :         (__logmsg).append("[TODO])\n");
        2652               0 :         fputs((__logmsg).c_str(), __outf);
        2653               0 :     }
        2654                 : };
        2655                 :
        2656                 : class Reply_ReadPermissions :
        2657                 :     public IPC::Message
        2658               0 : {
        2659                 : private:
        2660                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2661                 :     typedef mozilla::dom::StorageClone StorageClone;
        2662                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2663                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2664                 :     typedef mozilla::ipc::Shmem Shmem;
        2665                 :     typedef IPC::URI URI;
        2666                 :     typedef IPC::Permission Permission;
        2667                 :     typedef mozilla::null_t null_t;
        2668                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2669                 :
        2670                 : public:
        2671                 :     enum {
        2672                 :         ID = Reply_ReadPermissions__ID
        2673                 :     };
        2674               0 :     Reply_ReadPermissions() :
        2675               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_ReadPermissions")
        2676                 :     {
        2677               0 :     }
        2678                 :
        2679                 :     void
        2680               0 :     Log(
        2681                 :             const std::string& __pfx,
        2682                 :             FILE* __outf) const
        2683                 :     {
        2684               0 :         std::string __logmsg;
        2685               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2686               0 :         (__logmsg).append(__pfx);
        2687               0 :         (__logmsg).append("Reply_ReadPermissions(");
        2688                 :
        2689               0 :         (__logmsg).append("[TODO])\n");
        2690               0 :         fputs((__logmsg).c_str(), __outf);
        2691               0 :     }
        2692                 : };
        2693                 :
        2694                 : class Msg_GetIndexedDBDirectory :
        2695                 :     public IPC::Message
        2696               0 : {
        2697                 : private:
        2698                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2699                 :     typedef mozilla::dom::StorageClone StorageClone;
        2700                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2701                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2702                 :     typedef mozilla::ipc::Shmem Shmem;
        2703                 :     typedef IPC::URI URI;
        2704                 :     typedef IPC::Permission Permission;
        2705                 :     typedef mozilla::null_t null_t;
        2706                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2707                 :
        2708                 : public:
        2709                 :     enum {
        2710                 :         ID = Msg_GetIndexedDBDirectory__ID
        2711                 :     };
        2712               0 :     Msg_GetIndexedDBDirectory() :
        2713               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GetIndexedDBDirectory")
        2714                 :     {
        2715               0 :     }
        2716                 :
        2717                 :     void
        2718               0 :     Log(
        2719                 :             const std::string& __pfx,
        2720                 :             FILE* __outf) const
        2721                 :     {
        2722               0 :         std::string __logmsg;
        2723               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2724               0 :         (__logmsg).append(__pfx);
        2725               0 :         (__logmsg).append("Msg_GetIndexedDBDirectory(");
        2726                 :
        2727               0 :         (__logmsg).append("[TODO])\n");
        2728               0 :         fputs((__logmsg).c_str(), __outf);
        2729               0 :     }
        2730                 : };
        2731                 :
        2732                 : class Reply_GetIndexedDBDirectory :
        2733                 :     public IPC::Message
        2734               0 : {
        2735                 : private:
        2736                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2737                 :     typedef mozilla::dom::StorageClone StorageClone;
        2738                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2739                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2740                 :     typedef mozilla::ipc::Shmem Shmem;
        2741                 :     typedef IPC::URI URI;
        2742                 :     typedef IPC::Permission Permission;
        2743                 :     typedef mozilla::null_t null_t;
        2744                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2745                 :
        2746                 : public:
        2747                 :     enum {
        2748                 :         ID = Reply_GetIndexedDBDirectory__ID
        2749                 :     };
        2750               0 :     Reply_GetIndexedDBDirectory() :
        2751               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_GetIndexedDBDirectory")
        2752                 :     {
        2753               0 :     }
        2754                 :
        2755                 :     void
        2756               0 :     Log(
        2757                 :             const std::string& __pfx,
        2758                 :             FILE* __outf) const
        2759                 :     {
        2760               0 :         std::string __logmsg;
        2761               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2762               0 :         (__logmsg).append(__pfx);
        2763               0 :         (__logmsg).append("Reply_GetIndexedDBDirectory(");
        2764                 :
        2765               0 :         (__logmsg).append("[TODO])\n");
        2766               0 :         fputs((__logmsg).c_str(), __outf);
        2767               0 :     }
        2768                 : };
        2769                 :
        2770                 : class Msg_SetClipboardText :
        2771                 :     public IPC::Message
        2772               0 : {
        2773                 : private:
        2774                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2775                 :     typedef mozilla::dom::StorageClone StorageClone;
        2776                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2777                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2778                 :     typedef mozilla::ipc::Shmem Shmem;
        2779                 :     typedef IPC::URI URI;
        2780                 :     typedef IPC::Permission Permission;
        2781                 :     typedef mozilla::null_t null_t;
        2782                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2783                 :
        2784                 : public:
        2785                 :     enum {
        2786                 :         ID = Msg_SetClipboardText__ID
        2787                 :     };
        2788               0 :     Msg_SetClipboardText() :
        2789               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_SetClipboardText")
        2790                 :     {
        2791               0 :     }
        2792                 :
        2793                 :     void
        2794               0 :     Log(
        2795                 :             const std::string& __pfx,
        2796                 :             FILE* __outf) const
        2797                 :     {
        2798               0 :         std::string __logmsg;
        2799               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2800               0 :         (__logmsg).append(__pfx);
        2801               0 :         (__logmsg).append("Msg_SetClipboardText(");
        2802                 :
        2803               0 :         (__logmsg).append("[TODO])\n");
        2804               0 :         fputs((__logmsg).c_str(), __outf);
        2805               0 :     }
        2806                 : };
        2807                 :
        2808                 : class Msg_GetClipboardText :
        2809                 :     public IPC::Message
        2810               0 : {
        2811                 : private:
        2812                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2813                 :     typedef mozilla::dom::StorageClone StorageClone;
        2814                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2815                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2816                 :     typedef mozilla::ipc::Shmem Shmem;
        2817                 :     typedef IPC::URI URI;
        2818                 :     typedef IPC::Permission Permission;
        2819                 :     typedef mozilla::null_t null_t;
        2820                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2821                 :
        2822                 : public:
        2823                 :     enum {
        2824                 :         ID = Msg_GetClipboardText__ID
        2825                 :     };
        2826               0 :     Msg_GetClipboardText() :
        2827               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GetClipboardText")
        2828                 :     {
        2829               0 :     }
        2830                 :
        2831                 :     void
        2832               0 :     Log(
        2833                 :             const std::string& __pfx,
        2834                 :             FILE* __outf) const
        2835                 :     {
        2836               0 :         std::string __logmsg;
        2837               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2838               0 :         (__logmsg).append(__pfx);
        2839               0 :         (__logmsg).append("Msg_GetClipboardText(");
        2840                 :
        2841               0 :         (__logmsg).append("[TODO])\n");
        2842               0 :         fputs((__logmsg).c_str(), __outf);
        2843               0 :     }
        2844                 : };
        2845                 :
        2846                 : class Reply_GetClipboardText :
        2847                 :     public IPC::Message
        2848               0 : {
        2849                 : private:
        2850                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2851                 :     typedef mozilla::dom::StorageClone StorageClone;
        2852                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2853                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2854                 :     typedef mozilla::ipc::Shmem Shmem;
        2855                 :     typedef IPC::URI URI;
        2856                 :     typedef IPC::Permission Permission;
        2857                 :     typedef mozilla::null_t null_t;
        2858                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2859                 :
        2860                 : public:
        2861                 :     enum {
        2862                 :         ID = Reply_GetClipboardText__ID
        2863                 :     };
        2864               0 :     Reply_GetClipboardText() :
        2865               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_GetClipboardText")
        2866                 :     {
        2867               0 :     }
        2868                 :
        2869                 :     void
        2870               0 :     Log(
        2871                 :             const std::string& __pfx,
        2872                 :             FILE* __outf) const
        2873                 :     {
        2874               0 :         std::string __logmsg;
        2875               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2876               0 :         (__logmsg).append(__pfx);
        2877               0 :         (__logmsg).append("Reply_GetClipboardText(");
        2878                 :
        2879               0 :         (__logmsg).append("[TODO])\n");
        2880               0 :         fputs((__logmsg).c_str(), __outf);
        2881               0 :     }
        2882                 : };
        2883                 :
        2884                 : class Msg_EmptyClipboard :
        2885                 :     public IPC::Message
        2886               0 : {
        2887                 : private:
        2888                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2889                 :     typedef mozilla::dom::StorageClone StorageClone;
        2890                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2891                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2892                 :     typedef mozilla::ipc::Shmem Shmem;
        2893                 :     typedef IPC::URI URI;
        2894                 :     typedef IPC::Permission Permission;
        2895                 :     typedef mozilla::null_t null_t;
        2896                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2897                 :
        2898                 : public:
        2899                 :     enum {
        2900                 :         ID = Msg_EmptyClipboard__ID
        2901                 :     };
        2902               0 :     Msg_EmptyClipboard() :
        2903               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_EmptyClipboard")
        2904                 :     {
        2905               0 :     }
        2906                 :
        2907                 :     void
        2908               0 :     Log(
        2909                 :             const std::string& __pfx,
        2910                 :             FILE* __outf) const
        2911                 :     {
        2912               0 :         std::string __logmsg;
        2913               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2914               0 :         (__logmsg).append(__pfx);
        2915               0 :         (__logmsg).append("Msg_EmptyClipboard(");
        2916                 :
        2917               0 :         (__logmsg).append("[TODO])\n");
        2918               0 :         fputs((__logmsg).c_str(), __outf);
        2919               0 :     }
        2920                 : };
        2921                 :
        2922                 : class Msg_ClipboardHasText :
        2923                 :     public IPC::Message
        2924               0 : {
        2925                 : private:
        2926                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2927                 :     typedef mozilla::dom::StorageClone StorageClone;
        2928                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2929                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2930                 :     typedef mozilla::ipc::Shmem Shmem;
        2931                 :     typedef IPC::URI URI;
        2932                 :     typedef IPC::Permission Permission;
        2933                 :     typedef mozilla::null_t null_t;
        2934                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2935                 :
        2936                 : public:
        2937                 :     enum {
        2938                 :         ID = Msg_ClipboardHasText__ID
        2939                 :     };
        2940               0 :     Msg_ClipboardHasText() :
        2941               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_ClipboardHasText")
        2942                 :     {
        2943               0 :     }
        2944                 :
        2945                 :     void
        2946               0 :     Log(
        2947                 :             const std::string& __pfx,
        2948                 :             FILE* __outf) const
        2949                 :     {
        2950               0 :         std::string __logmsg;
        2951               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2952               0 :         (__logmsg).append(__pfx);
        2953               0 :         (__logmsg).append("Msg_ClipboardHasText(");
        2954                 :
        2955               0 :         (__logmsg).append("[TODO])\n");
        2956               0 :         fputs((__logmsg).c_str(), __outf);
        2957               0 :     }
        2958                 : };
        2959                 :
        2960                 : class Reply_ClipboardHasText :
        2961                 :     public IPC::Message
        2962               0 : {
        2963                 : private:
        2964                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        2965                 :     typedef mozilla::dom::StorageClone StorageClone;
        2966                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        2967                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        2968                 :     typedef mozilla::ipc::Shmem Shmem;
        2969                 :     typedef IPC::URI URI;
        2970                 :     typedef IPC::Permission Permission;
        2971                 :     typedef mozilla::null_t null_t;
        2972                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        2973                 :
        2974                 : public:
        2975                 :     enum {
        2976                 :         ID = Reply_ClipboardHasText__ID
        2977                 :     };
        2978               0 :     Reply_ClipboardHasText() :
        2979               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_ClipboardHasText")
        2980                 :     {
        2981               0 :     }
        2982                 :
        2983                 :     void
        2984               0 :     Log(
        2985                 :             const std::string& __pfx,
        2986                 :             FILE* __outf) const
        2987                 :     {
        2988               0 :         std::string __logmsg;
        2989               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        2990               0 :         (__logmsg).append(__pfx);
        2991               0 :         (__logmsg).append("Reply_ClipboardHasText(");
        2992                 :
        2993               0 :         (__logmsg).append("[TODO])\n");
        2994               0 :         fputs((__logmsg).c_str(), __outf);
        2995               0 :     }
        2996                 : };
        2997                 :
        2998                 : class Msg_GetSystemColors :
        2999                 :     public IPC::Message
        3000               0 : {
        3001                 : private:
        3002                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3003                 :     typedef mozilla::dom::StorageClone StorageClone;
        3004                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3005                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3006                 :     typedef mozilla::ipc::Shmem Shmem;
        3007                 :     typedef IPC::URI URI;
        3008                 :     typedef IPC::Permission Permission;
        3009                 :     typedef mozilla::null_t null_t;
        3010                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3011                 :
        3012                 : public:
        3013                 :     enum {
        3014                 :         ID = Msg_GetSystemColors__ID
        3015                 :     };
        3016               0 :     Msg_GetSystemColors() :
        3017               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GetSystemColors")
        3018                 :     {
        3019               0 :     }
        3020                 :
        3021                 :     void
        3022               0 :     Log(
        3023                 :             const std::string& __pfx,
        3024                 :             FILE* __outf) const
        3025                 :     {
        3026               0 :         std::string __logmsg;
        3027               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3028               0 :         (__logmsg).append(__pfx);
        3029               0 :         (__logmsg).append("Msg_GetSystemColors(");
        3030                 :
        3031               0 :         (__logmsg).append("[TODO])\n");
        3032               0 :         fputs((__logmsg).c_str(), __outf);
        3033               0 :     }
        3034                 : };
        3035                 :
        3036                 : class Reply_GetSystemColors :
        3037                 :     public IPC::Message
        3038               0 : {
        3039                 : private:
        3040                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3041                 :     typedef mozilla::dom::StorageClone StorageClone;
        3042                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3043                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3044                 :     typedef mozilla::ipc::Shmem Shmem;
        3045                 :     typedef IPC::URI URI;
        3046                 :     typedef IPC::Permission Permission;
        3047                 :     typedef mozilla::null_t null_t;
        3048                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3049                 :
        3050                 : public:
        3051                 :     enum {
        3052                 :         ID = Reply_GetSystemColors__ID
        3053                 :     };
        3054               0 :     Reply_GetSystemColors() :
        3055               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_GetSystemColors")
        3056                 :     {
        3057               0 :     }
        3058                 :
        3059                 :     void
        3060               0 :     Log(
        3061                 :             const std::string& __pfx,
        3062                 :             FILE* __outf) const
        3063                 :     {
        3064               0 :         std::string __logmsg;
        3065               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3066               0 :         (__logmsg).append(__pfx);
        3067               0 :         (__logmsg).append("Reply_GetSystemColors(");
        3068                 :
        3069               0 :         (__logmsg).append("[TODO])\n");
        3070               0 :         fputs((__logmsg).c_str(), __outf);
        3071               0 :     }
        3072                 : };
        3073                 :
        3074                 : class Msg_GetIconForExtension :
        3075                 :     public IPC::Message
        3076               0 : {
        3077                 : private:
        3078                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3079                 :     typedef mozilla::dom::StorageClone StorageClone;
        3080                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3081                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3082                 :     typedef mozilla::ipc::Shmem Shmem;
        3083                 :     typedef IPC::URI URI;
        3084                 :     typedef IPC::Permission Permission;
        3085                 :     typedef mozilla::null_t null_t;
        3086                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3087                 :
        3088                 : public:
        3089                 :     enum {
        3090                 :         ID = Msg_GetIconForExtension__ID
        3091                 :     };
        3092               0 :     Msg_GetIconForExtension() :
        3093               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GetIconForExtension")
        3094                 :     {
        3095               0 :     }
        3096                 :
        3097                 :     void
        3098               0 :     Log(
        3099                 :             const std::string& __pfx,
        3100                 :             FILE* __outf) const
        3101                 :     {
        3102               0 :         std::string __logmsg;
        3103               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3104               0 :         (__logmsg).append(__pfx);
        3105               0 :         (__logmsg).append("Msg_GetIconForExtension(");
        3106                 :
        3107               0 :         (__logmsg).append("[TODO])\n");
        3108               0 :         fputs((__logmsg).c_str(), __outf);
        3109               0 :     }
        3110                 : };
        3111                 :
        3112                 : class Reply_GetIconForExtension :
        3113                 :     public IPC::Message
        3114               0 : {
        3115                 : private:
        3116                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3117                 :     typedef mozilla::dom::StorageClone StorageClone;
        3118                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3119                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3120                 :     typedef mozilla::ipc::Shmem Shmem;
        3121                 :     typedef IPC::URI URI;
        3122                 :     typedef IPC::Permission Permission;
        3123                 :     typedef mozilla::null_t null_t;
        3124                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3125                 :
        3126                 : public:
        3127                 :     enum {
        3128                 :         ID = Reply_GetIconForExtension__ID
        3129                 :     };
        3130               0 :     Reply_GetIconForExtension() :
        3131               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_GetIconForExtension")
        3132                 :     {
        3133               0 :     }
        3134                 :
        3135                 :     void
        3136               0 :     Log(
        3137                 :             const std::string& __pfx,
        3138                 :             FILE* __outf) const
        3139                 :     {
        3140               0 :         std::string __logmsg;
        3141               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3142               0 :         (__logmsg).append(__pfx);
        3143               0 :         (__logmsg).append("Reply_GetIconForExtension(");
        3144                 :
        3145               0 :         (__logmsg).append("[TODO])\n");
        3146               0 :         fputs((__logmsg).c_str(), __outf);
        3147               0 :     }
        3148                 : };
        3149                 :
        3150                 : class Msg_GetShowPasswordSetting :
        3151                 :     public IPC::Message
        3152               0 : {
        3153                 : private:
        3154                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3155                 :     typedef mozilla::dom::StorageClone StorageClone;
        3156                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3157                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3158                 :     typedef mozilla::ipc::Shmem Shmem;
        3159                 :     typedef IPC::URI URI;
        3160                 :     typedef IPC::Permission Permission;
        3161                 :     typedef mozilla::null_t null_t;
        3162                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3163                 :
        3164                 : public:
        3165                 :     enum {
        3166                 :         ID = Msg_GetShowPasswordSetting__ID
        3167                 :     };
        3168               0 :     Msg_GetShowPasswordSetting() :
        3169               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_GetShowPasswordSetting")
        3170                 :     {
        3171               0 :     }
        3172                 :
        3173                 :     void
        3174               0 :     Log(
        3175                 :             const std::string& __pfx,
        3176                 :             FILE* __outf) const
        3177                 :     {
        3178               0 :         std::string __logmsg;
        3179               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3180               0 :         (__logmsg).append(__pfx);
        3181               0 :         (__logmsg).append("Msg_GetShowPasswordSetting(");
        3182                 :
        3183               0 :         (__logmsg).append("[TODO])\n");
        3184               0 :         fputs((__logmsg).c_str(), __outf);
        3185               0 :     }
        3186                 : };
        3187                 :
        3188                 : class Reply_GetShowPasswordSetting :
        3189                 :     public IPC::Message
        3190               0 : {
        3191                 : private:
        3192                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3193                 :     typedef mozilla::dom::StorageClone StorageClone;
        3194                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3195                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3196                 :     typedef mozilla::ipc::Shmem Shmem;
        3197                 :     typedef IPC::URI URI;
        3198                 :     typedef IPC::Permission Permission;
        3199                 :     typedef mozilla::null_t null_t;
        3200                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3201                 :
        3202                 : public:
        3203                 :     enum {
        3204                 :         ID = Reply_GetShowPasswordSetting__ID
        3205                 :     };
        3206               0 :     Reply_GetShowPasswordSetting() :
        3207               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Reply_GetShowPasswordSetting")
        3208                 :     {
        3209               0 :     }
        3210                 :
        3211                 :     void
        3212               0 :     Log(
        3213                 :             const std::string& __pfx,
        3214                 :             FILE* __outf) const
        3215                 :     {
        3216               0 :         std::string __logmsg;
        3217               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3218               0 :         (__logmsg).append(__pfx);
        3219               0 :         (__logmsg).append("Reply_GetShowPasswordSetting(");
        3220                 :
        3221               0 :         (__logmsg).append("[TODO])\n");
        3222               0 :         fputs((__logmsg).c_str(), __outf);
        3223               0 :     }
        3224                 : };
        3225                 :
        3226                 : class Msg_AsyncMessage :
        3227                 :     public IPC::Message
        3228               0 : {
        3229                 : private:
        3230                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
        3231                 :     typedef mozilla::dom::StorageClone StorageClone;
        3232                 :     typedef mozilla::dom::StorageConstructData StorageConstructData;
        3233                 :     typedef mozilla::dom::FontListEntry FontListEntry;
        3234                 :     typedef mozilla::ipc::Shmem Shmem;
        3235                 :     typedef IPC::URI URI;
        3236                 :     typedef IPC::Permission Permission;
        3237                 :     typedef mozilla::null_t null_t;
        3238                 :     typedef mozilla::dom::NativeThreadId NativeThreadId;
        3239                 :
        3240                 : public:
        3241                 :     enum {
        3242                 :         ID = Msg_AsyncMessage__ID
        3243                 :     };
        3244               0 :     Msg_AsyncMessage() :
        3245               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PContent::Msg_AsyncMessage")
        3246                 :     {
        3247               0 :     }
        3248                 :
        3249                 :     void
        3250               0 :     Log(
        3251                 :             const std::string& __pfx,
        3252                 :             FILE* __outf) const
        3253                 :     {
        3254               0 :         std::string __logmsg;
        3255               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
        3256               0 :         (__logmsg).append(__pfx);
        3257               0 :         (__logmsg).append("Msg_AsyncMessage(");
        3258                 :
        3259               0 :         (__logmsg).append("[TODO])\n");
        3260               0 :         fputs((__logmsg).c_str(), __outf);
        3261               0 :     }
        3262                 : };
        3263                 :
        3264                 :
        3265                 :
        3266                 : } // namespace PContent
        3267                 : } // namespace dom
        3268                 : } // namespace mozilla
        3269                 :
        3270                 : #endif // ifndef PContent_h

Generated by: LCOV version 1.7