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