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

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : #ifndef PPluginScriptableObject_h
       7                 : #define PPluginScriptableObject_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 "npapi.h"
      21                 : #include "npruntime.h"
      22                 : #include "mozilla/plugins/PluginMessageUtils.h"
      23                 : 
      24                 : namespace mozilla {
      25                 : namespace plugins {
      26                 : class PPluginScriptableObjectParent;
      27                 : } // namespace plugins
      28                 : } // namespace mozilla
      29                 : 
      30                 : namespace mozilla {
      31                 : namespace plugins {
      32                 : class PPluginScriptableObjectChild;
      33                 : } // namespace plugins
      34                 : } // namespace mozilla
      35                 : 
      36                 : 
      37                 : //-----------------------------------------------------------------------------
      38                 : // Declaration of the IPDL type |union Variant|
      39                 : //
      40                 : namespace mozilla {
      41                 : namespace plugins {
      42                 : class Variant MOZ_FINAL
      43                 : {
      44                 : public:
      45                 :     enum Type {
      46                 :         T__None,
      47                 :         Tvoid_t = 1,
      48                 :         Tnull_t,
      49                 :         Tbool,
      50                 :         Tint,
      51                 :         Tdouble,
      52                 :         TnsCString,
      53                 :         TPPluginScriptableObjectParent,
      54                 :         TPPluginScriptableObjectChild,
      55                 :         T__Last = TPPluginScriptableObjectChild
      56                 :     };
      57                 : 
      58                 : private:
      59                 :     typedef mozilla::void_t void_t;
      60                 :     typedef mozilla::null_t null_t;
      61                 :     typedef mozilla::plugins::PPluginScriptableObjectParent PPluginScriptableObjectParent;
      62                 :     typedef mozilla::plugins::PPluginScriptableObjectChild PPluginScriptableObjectChild;
      63                 :     typedef void_t void_t__tdef;
      64                 :     typedef null_t null_t__tdef;
      65                 :     typedef bool bool__tdef;
      66                 :     typedef int int__tdef;
      67                 :     typedef double double__tdef;
      68                 :     typedef nsCString nsCString__tdef;
      69                 :     typedef PPluginScriptableObjectParent* PPluginScriptableObjectParent__tdef;
      70                 :     typedef PPluginScriptableObjectChild* PPluginScriptableObjectChild__tdef;
      71                 : 
      72                 :     union Value {
      73                 :         char Vvoid_t[sizeof(void_t)];
      74                 :         char Vnull_t[sizeof(null_t)];
      75                 :         char Vbool[sizeof(bool)];
      76                 :         char Vint[sizeof(int)];
      77                 :         char Vdouble[sizeof(double)];
      78                 :         char VnsCString[sizeof(nsCString)];
      79                 :         char VPPluginScriptableObjectParent[sizeof(PPluginScriptableObjectParent*)];
      80                 :         char VPPluginScriptableObjectChild[sizeof(PPluginScriptableObjectChild*)];
      81                 :     };
      82                 : 
      83                 :     void_t*
      84               0 :     ptr_void_t()
      85                 :     {
      86               0 :         return reinterpret_cast<void_t*>((&((mValue).Vvoid_t)));
      87                 :     }
      88                 :     const void_t* const
      89               0 :     constptr_void_t() const
      90                 :     {
      91               0 :         return reinterpret_cast<const void_t* const>((&((mValue).Vvoid_t)));
      92                 :     }
      93                 :     null_t*
      94               0 :     ptr_null_t()
      95                 :     {
      96               0 :         return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
      97                 :     }
      98                 :     const null_t* const
      99               0 :     constptr_null_t() const
     100                 :     {
     101               0 :         return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
     102                 :     }
     103                 :     bool*
     104               0 :     ptr_bool()
     105                 :     {
     106               0 :         return reinterpret_cast<bool*>((&((mValue).Vbool)));
     107                 :     }
     108                 :     const bool* const
     109               0 :     constptr_bool() const
     110                 :     {
     111               0 :         return reinterpret_cast<const bool* const>((&((mValue).Vbool)));
     112                 :     }
     113                 :     int*
     114               0 :     ptr_int()
     115                 :     {
     116               0 :         return reinterpret_cast<int*>((&((mValue).Vint)));
     117                 :     }
     118                 :     const int* const
     119               0 :     constptr_int() const
     120                 :     {
     121               0 :         return reinterpret_cast<const int* const>((&((mValue).Vint)));
     122                 :     }
     123                 :     double*
     124               0 :     ptr_double()
     125                 :     {
     126               0 :         return reinterpret_cast<double*>((&((mValue).Vdouble)));
     127                 :     }
     128                 :     const double* const
     129               0 :     constptr_double() const
     130                 :     {
     131               0 :         return reinterpret_cast<const double* const>((&((mValue).Vdouble)));
     132                 :     }
     133                 :     nsCString*
     134               0 :     ptr_nsCString()
     135                 :     {
     136               0 :         return reinterpret_cast<nsCString*>((&((mValue).VnsCString)));
     137                 :     }
     138                 :     const nsCString* const
     139               0 :     constptr_nsCString() const
     140                 :     {
     141               0 :         return reinterpret_cast<const nsCString* const>((&((mValue).VnsCString)));
     142                 :     }
     143                 :     PPluginScriptableObjectParent**
     144               0 :     ptr_PPluginScriptableObjectParent()
     145                 :     {
     146               0 :         return reinterpret_cast<PPluginScriptableObjectParent**>((&((mValue).VPPluginScriptableObjectParent)));
     147                 :     }
     148                 :     PPluginScriptableObjectParent* const*
     149               0 :     constptr_PPluginScriptableObjectParent() const
     150                 :     {
     151               0 :         return reinterpret_cast<PPluginScriptableObjectParent* const*>((&((mValue).VPPluginScriptableObjectParent)));
     152                 :     }
     153                 :     PPluginScriptableObjectChild**
     154               0 :     ptr_PPluginScriptableObjectChild()
     155                 :     {
     156               0 :         return reinterpret_cast<PPluginScriptableObjectChild**>((&((mValue).VPPluginScriptableObjectChild)));
     157                 :     }
     158                 :     PPluginScriptableObjectChild* const*
     159               0 :     constptr_PPluginScriptableObjectChild() const
     160                 :     {
     161               0 :         return reinterpret_cast<PPluginScriptableObjectChild* const*>((&((mValue).VPPluginScriptableObjectChild)));
     162                 :     }
     163                 : 
     164                 :     bool
     165                 :     MaybeDestroy(Type aNewType);
     166                 : 
     167                 :     void
     168               0 :     AssertSanity() const
     169                 :     {
     170               0 :         NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
     171               0 :         NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
     172               0 :     }
     173                 :     void
     174               0 :     AssertSanity(Type aType) const
     175                 :     {
     176               0 :         AssertSanity();
     177               0 :         NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
     178               0 :     }
     179                 : 
     180                 : public:
     181               0 :     Variant() :
     182               0 :         mType(T__None)
     183                 :     {
     184               0 :     }
     185                 : 
     186                 :     Variant(const void_t& aOther);
     187                 : 
     188                 :     Variant(const null_t& aOther);
     189                 : 
     190                 :     Variant(const bool& aOther);
     191                 : 
     192                 :     Variant(const int& aOther);
     193                 : 
     194                 :     Variant(const double& aOther);
     195                 : 
     196                 :     Variant(const nsCString& aOther);
     197                 : 
     198                 :     Variant(PPluginScriptableObjectParent* aOther);
     199                 : 
     200                 :     Variant(PPluginScriptableObjectChild* aOther);
     201                 : 
     202                 :     Variant(const Variant& aOther);
     203                 : 
     204                 :     ~Variant();
     205                 : 
     206                 :     Type
     207               0 :     type() const
     208                 :     {
     209               0 :         return mType;
     210                 :     }
     211                 : 
     212                 :     Variant&
     213                 :     operator=(const void_t& aRhs);
     214                 : 
     215                 :     Variant&
     216                 :     operator=(const null_t& aRhs);
     217                 : 
     218                 :     Variant&
     219                 :     operator=(const bool& aRhs);
     220                 : 
     221                 :     Variant&
     222                 :     operator=(const int& aRhs);
     223                 : 
     224                 :     Variant&
     225                 :     operator=(const double& aRhs);
     226                 : 
     227                 :     Variant&
     228                 :     operator=(const nsCString& aRhs);
     229                 : 
     230                 :     Variant&
     231                 :     operator=(PPluginScriptableObjectParent* aRhs);
     232                 : 
     233                 :     Variant&
     234                 :     operator=(PPluginScriptableObjectChild* aRhs);
     235                 : 
     236                 :     Variant&
     237                 :     operator=(const Variant& aRhs);
     238                 : 
     239                 :     bool
     240                 :     operator==(const void_t& aRhs) const;
     241                 : 
     242                 :     bool
     243                 :     operator==(const null_t& aRhs) const;
     244                 : 
     245                 :     bool
     246                 :     operator==(const bool& aRhs) const;
     247                 : 
     248                 :     bool
     249                 :     operator==(const int& aRhs) const;
     250                 : 
     251                 :     bool
     252                 :     operator==(const double& aRhs) const;
     253                 : 
     254                 :     bool
     255                 :     operator==(const nsCString& aRhs) const;
     256                 : 
     257                 :     bool
     258                 :     operator==(PPluginScriptableObjectParent* aRhs) const;
     259                 : 
     260                 :     bool
     261                 :     operator==(PPluginScriptableObjectChild* aRhs) const;
     262                 : 
     263                 :     bool
     264                 :     operator==(const Variant& aRhs) const;
     265                 : 
     266                 :     void_t&
     267               0 :     get_void_t()
     268                 :     {
     269               0 :         AssertSanity(Tvoid_t);
     270               0 :         return (*(ptr_void_t()));
     271                 :     }
     272                 :     const void_t&
     273               0 :     get_void_t() const
     274                 :     {
     275               0 :         AssertSanity(Tvoid_t);
     276               0 :         return (*(constptr_void_t()));
     277                 :     }
     278                 :     operator void_t&()
     279                 :     {
     280                 :         return get_void_t();
     281                 :     }
     282                 :     operator const void_t&() const
     283                 :     {
     284                 :         return get_void_t();
     285                 :     }
     286                 : 
     287                 :     null_t&
     288               0 :     get_null_t()
     289                 :     {
     290               0 :         AssertSanity(Tnull_t);
     291               0 :         return (*(ptr_null_t()));
     292                 :     }
     293                 :     const null_t&
     294               0 :     get_null_t() const
     295                 :     {
     296               0 :         AssertSanity(Tnull_t);
     297               0 :         return (*(constptr_null_t()));
     298                 :     }
     299                 :     operator null_t&()
     300                 :     {
     301                 :         return get_null_t();
     302                 :     }
     303                 :     operator const null_t&() const
     304                 :     {
     305                 :         return get_null_t();
     306                 :     }
     307                 : 
     308                 :     bool&
     309               0 :     get_bool()
     310                 :     {
     311               0 :         AssertSanity(Tbool);
     312               0 :         return (*(ptr_bool()));
     313                 :     }
     314                 :     const bool&
     315               0 :     get_bool() const
     316                 :     {
     317               0 :         AssertSanity(Tbool);
     318               0 :         return (*(constptr_bool()));
     319                 :     }
     320                 :     operator bool&()
     321                 :     {
     322                 :         return get_bool();
     323                 :     }
     324                 :     operator const bool&() const
     325                 :     {
     326                 :         return get_bool();
     327                 :     }
     328                 : 
     329                 :     int&
     330               0 :     get_int()
     331                 :     {
     332               0 :         AssertSanity(Tint);
     333               0 :         return (*(ptr_int()));
     334                 :     }
     335                 :     const int&
     336               0 :     get_int() const
     337                 :     {
     338               0 :         AssertSanity(Tint);
     339               0 :         return (*(constptr_int()));
     340                 :     }
     341                 :     operator int&()
     342                 :     {
     343                 :         return get_int();
     344                 :     }
     345                 :     operator const int&() const
     346                 :     {
     347                 :         return get_int();
     348                 :     }
     349                 : 
     350                 :     double&
     351               0 :     get_double()
     352                 :     {
     353               0 :         AssertSanity(Tdouble);
     354               0 :         return (*(ptr_double()));
     355                 :     }
     356                 :     const double&
     357               0 :     get_double() const
     358                 :     {
     359               0 :         AssertSanity(Tdouble);
     360               0 :         return (*(constptr_double()));
     361                 :     }
     362                 :     operator double&()
     363                 :     {
     364                 :         return get_double();
     365                 :     }
     366                 :     operator const double&() const
     367                 :     {
     368                 :         return get_double();
     369                 :     }
     370                 : 
     371                 :     nsCString&
     372               0 :     get_nsCString()
     373                 :     {
     374               0 :         AssertSanity(TnsCString);
     375               0 :         return (*(ptr_nsCString()));
     376                 :     }
     377                 :     const nsCString&
     378               0 :     get_nsCString() const
     379                 :     {
     380               0 :         AssertSanity(TnsCString);
     381               0 :         return (*(constptr_nsCString()));
     382                 :     }
     383                 :     operator nsCString&()
     384                 :     {
     385                 :         return get_nsCString();
     386                 :     }
     387                 :     operator const nsCString&() const
     388                 :     {
     389                 :         return get_nsCString();
     390                 :     }
     391                 : 
     392                 :     PPluginScriptableObjectParent*&
     393               0 :     get_PPluginScriptableObjectParent()
     394                 :     {
     395               0 :         AssertSanity(TPPluginScriptableObjectParent);
     396               0 :         return (*(ptr_PPluginScriptableObjectParent()));
     397                 :     }
     398                 :     PPluginScriptableObjectParent*
     399               0 :     get_PPluginScriptableObjectParent() const
     400                 :     {
     401               0 :         AssertSanity(TPPluginScriptableObjectParent);
     402               0 :         return (*(constptr_PPluginScriptableObjectParent()));
     403                 :     }
     404                 :     operator PPluginScriptableObjectParent*&()
     405                 :     {
     406                 :         return get_PPluginScriptableObjectParent();
     407                 :     }
     408                 :     operator PPluginScriptableObjectParent*() const
     409                 :     {
     410                 :         return get_PPluginScriptableObjectParent();
     411                 :     }
     412                 : 
     413                 :     PPluginScriptableObjectChild*&
     414               0 :     get_PPluginScriptableObjectChild()
     415                 :     {
     416               0 :         AssertSanity(TPPluginScriptableObjectChild);
     417               0 :         return (*(ptr_PPluginScriptableObjectChild()));
     418                 :     }
     419                 :     PPluginScriptableObjectChild*
     420               0 :     get_PPluginScriptableObjectChild() const
     421                 :     {
     422               0 :         AssertSanity(TPPluginScriptableObjectChild);
     423               0 :         return (*(constptr_PPluginScriptableObjectChild()));
     424                 :     }
     425                 :     operator PPluginScriptableObjectChild*&()
     426                 :     {
     427                 :         return get_PPluginScriptableObjectChild();
     428                 :     }
     429                 :     operator PPluginScriptableObjectChild*() const
     430                 :     {
     431                 :         return get_PPluginScriptableObjectChild();
     432                 :     }
     433                 : 
     434                 : private:
     435                 :     Value mValue;
     436                 :     Type mType;
     437                 : };
     438                 : } // namespace plugins
     439                 : } // namespace mozilla
     440                 : 
     441                 : //-----------------------------------------------------------------------------
     442                 : // Code common to PPluginScriptableObjectChild and PPluginScriptableObjectParent
     443                 : //
     444                 : namespace mozilla {
     445                 : namespace plugins {
     446                 : namespace PPluginScriptableObject {
     447                 : 
     448                 : enum State {
     449                 :     __Dead,
     450                 :     __Null,
     451                 :     __Error,
     452                 :     __Start = __Null
     453                 : };
     454                 : 
     455                 : enum MessageType {
     456                 :     PPluginScriptableObjectStart = PPluginScriptableObjectMsgStart << 16,
     457                 :     PPluginScriptableObjectPreStart = (PPluginScriptableObjectMsgStart << 16) - 1,
     458                 :     Msg___delete____ID,
     459                 :     Reply___delete____ID,
     460                 :     Msg_NPN_Evaluate__ID,
     461                 :     Reply_NPN_Evaluate__ID,
     462                 :     Msg_Invalidate__ID,
     463                 :     Reply_Invalidate__ID,
     464                 :     Msg_HasMethod__ID,
     465                 :     Reply_HasMethod__ID,
     466                 :     Msg_Invoke__ID,
     467                 :     Reply_Invoke__ID,
     468                 :     Msg_InvokeDefault__ID,
     469                 :     Reply_InvokeDefault__ID,
     470                 :     Msg_HasProperty__ID,
     471                 :     Reply_HasProperty__ID,
     472                 :     Msg_SetProperty__ID,
     473                 :     Reply_SetProperty__ID,
     474                 :     Msg_RemoveProperty__ID,
     475                 :     Reply_RemoveProperty__ID,
     476                 :     Msg_Enumerate__ID,
     477                 :     Reply_Enumerate__ID,
     478                 :     Msg_Construct__ID,
     479                 :     Reply_Construct__ID,
     480                 :     Msg_Protect__ID,
     481                 :     Msg_Unprotect__ID,
     482                 :     Msg_GetParentProperty__ID,
     483                 :     Reply_GetParentProperty__ID,
     484                 :     Msg_GetChildProperty__ID,
     485                 :     Reply_GetChildProperty__ID,
     486                 :     PPluginScriptableObjectEnd
     487                 : };
     488                 : 
     489                 : bool
     490                 : Transition(
     491                 :         State from,
     492                 :         mozilla::ipc::Trigger trigger,
     493                 :         State* next);
     494                 : 
     495                 : class Msg___delete__ :
     496                 :     public IPC::Message
     497               0 : {
     498                 : private:
     499                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     500                 :     typedef mozilla::plugins::Variant Variant;
     501                 :     typedef mozilla::ipc::Shmem Shmem;
     502                 :     typedef mozilla::void_t void_t;
     503                 :     typedef mozilla::null_t null_t;
     504                 : 
     505                 : public:
     506                 :     enum {
     507                 :         ID = Msg___delete____ID
     508                 :     };
     509               0 :     Msg___delete__() :
     510               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg___delete__")
     511                 :     {
     512               0 :     }
     513                 : 
     514                 :     void
     515               0 :     Log(
     516                 :             const std::string& __pfx,
     517                 :             FILE* __outf) const
     518                 :     {
     519               0 :         std::string __logmsg;
     520               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     521               0 :         (__logmsg).append(__pfx);
     522               0 :         (__logmsg).append("Msg___delete__(");
     523                 : 
     524               0 :         (__logmsg).append("[TODO])\n");
     525               0 :         fputs((__logmsg).c_str(), __outf);
     526               0 :     }
     527                 : };
     528                 : 
     529                 : class Reply___delete__ :
     530                 :     public IPC::Message
     531                 : {
     532                 : private:
     533                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     534                 :     typedef mozilla::plugins::Variant Variant;
     535                 :     typedef mozilla::ipc::Shmem Shmem;
     536                 :     typedef mozilla::void_t void_t;
     537                 :     typedef mozilla::null_t null_t;
     538                 : 
     539                 : public:
     540                 :     enum {
     541                 :         ID = Reply___delete____ID
     542                 :     };
     543                 :     Reply___delete__() :
     544                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply___delete__")
     545                 :     {
     546                 :     }
     547                 : 
     548                 :     void
     549                 :     Log(
     550                 :             const std::string& __pfx,
     551                 :             FILE* __outf) const
     552                 :     {
     553                 :         std::string __logmsg;
     554                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     555                 :         (__logmsg).append(__pfx);
     556                 :         (__logmsg).append("Reply___delete__(");
     557                 : 
     558                 :         (__logmsg).append("[TODO])\n");
     559                 :         fputs((__logmsg).c_str(), __outf);
     560                 :     }
     561                 : };
     562                 : 
     563                 : class Msg_NPN_Evaluate :
     564                 :     public IPC::Message
     565               0 : {
     566                 : private:
     567                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     568                 :     typedef mozilla::plugins::Variant Variant;
     569                 :     typedef mozilla::ipc::Shmem Shmem;
     570                 :     typedef mozilla::void_t void_t;
     571                 :     typedef mozilla::null_t null_t;
     572                 : 
     573                 : public:
     574                 :     enum {
     575                 :         ID = Msg_NPN_Evaluate__ID
     576                 :     };
     577               0 :     Msg_NPN_Evaluate() :
     578               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_NPN_Evaluate")
     579                 :     {
     580               0 :     }
     581                 : 
     582                 :     void
     583               0 :     Log(
     584                 :             const std::string& __pfx,
     585                 :             FILE* __outf) const
     586                 :     {
     587               0 :         std::string __logmsg;
     588               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     589               0 :         (__logmsg).append(__pfx);
     590               0 :         (__logmsg).append("Msg_NPN_Evaluate(");
     591                 : 
     592               0 :         (__logmsg).append("[TODO])\n");
     593               0 :         fputs((__logmsg).c_str(), __outf);
     594               0 :     }
     595                 : };
     596                 : 
     597                 : class Reply_NPN_Evaluate :
     598                 :     public IPC::Message
     599               0 : {
     600                 : private:
     601                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     602                 :     typedef mozilla::plugins::Variant Variant;
     603                 :     typedef mozilla::ipc::Shmem Shmem;
     604                 :     typedef mozilla::void_t void_t;
     605                 :     typedef mozilla::null_t null_t;
     606                 : 
     607                 : public:
     608                 :     enum {
     609                 :         ID = Reply_NPN_Evaluate__ID
     610                 :     };
     611               0 :     Reply_NPN_Evaluate() :
     612               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_NPN_Evaluate")
     613                 :     {
     614               0 :     }
     615                 : 
     616                 :     void
     617               0 :     Log(
     618                 :             const std::string& __pfx,
     619                 :             FILE* __outf) const
     620                 :     {
     621               0 :         std::string __logmsg;
     622               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     623               0 :         (__logmsg).append(__pfx);
     624               0 :         (__logmsg).append("Reply_NPN_Evaluate(");
     625                 : 
     626               0 :         (__logmsg).append("[TODO])\n");
     627               0 :         fputs((__logmsg).c_str(), __outf);
     628               0 :     }
     629                 : };
     630                 : 
     631                 : class Msg_Invalidate :
     632                 :     public IPC::Message
     633               0 : {
     634                 : private:
     635                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     636                 :     typedef mozilla::plugins::Variant Variant;
     637                 :     typedef mozilla::ipc::Shmem Shmem;
     638                 :     typedef mozilla::void_t void_t;
     639                 :     typedef mozilla::null_t null_t;
     640                 : 
     641                 : public:
     642                 :     enum {
     643                 :         ID = Msg_Invalidate__ID
     644                 :     };
     645               0 :     Msg_Invalidate() :
     646               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Invalidate")
     647                 :     {
     648               0 :     }
     649                 : 
     650                 :     void
     651               0 :     Log(
     652                 :             const std::string& __pfx,
     653                 :             FILE* __outf) const
     654                 :     {
     655               0 :         std::string __logmsg;
     656               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     657               0 :         (__logmsg).append(__pfx);
     658               0 :         (__logmsg).append("Msg_Invalidate(");
     659                 : 
     660               0 :         (__logmsg).append("[TODO])\n");
     661               0 :         fputs((__logmsg).c_str(), __outf);
     662               0 :     }
     663                 : };
     664                 : 
     665                 : class Reply_Invalidate :
     666                 :     public IPC::Message
     667               0 : {
     668                 : private:
     669                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     670                 :     typedef mozilla::plugins::Variant Variant;
     671                 :     typedef mozilla::ipc::Shmem Shmem;
     672                 :     typedef mozilla::void_t void_t;
     673                 :     typedef mozilla::null_t null_t;
     674                 : 
     675                 : public:
     676                 :     enum {
     677                 :         ID = Reply_Invalidate__ID
     678                 :     };
     679               0 :     Reply_Invalidate() :
     680               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_Invalidate")
     681                 :     {
     682               0 :     }
     683                 : 
     684                 :     void
     685               0 :     Log(
     686                 :             const std::string& __pfx,
     687                 :             FILE* __outf) const
     688                 :     {
     689               0 :         std::string __logmsg;
     690               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     691               0 :         (__logmsg).append(__pfx);
     692               0 :         (__logmsg).append("Reply_Invalidate(");
     693                 : 
     694               0 :         (__logmsg).append("[TODO])\n");
     695               0 :         fputs((__logmsg).c_str(), __outf);
     696               0 :     }
     697                 : };
     698                 : 
     699                 : class Msg_HasMethod :
     700                 :     public IPC::Message
     701               0 : {
     702                 : private:
     703                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     704                 :     typedef mozilla::plugins::Variant Variant;
     705                 :     typedef mozilla::ipc::Shmem Shmem;
     706                 :     typedef mozilla::void_t void_t;
     707                 :     typedef mozilla::null_t null_t;
     708                 : 
     709                 : public:
     710                 :     enum {
     711                 :         ID = Msg_HasMethod__ID
     712                 :     };
     713               0 :     Msg_HasMethod() :
     714               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_HasMethod")
     715                 :     {
     716               0 :     }
     717                 : 
     718                 :     void
     719               0 :     Log(
     720                 :             const std::string& __pfx,
     721                 :             FILE* __outf) const
     722                 :     {
     723               0 :         std::string __logmsg;
     724               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     725               0 :         (__logmsg).append(__pfx);
     726               0 :         (__logmsg).append("Msg_HasMethod(");
     727                 : 
     728               0 :         (__logmsg).append("[TODO])\n");
     729               0 :         fputs((__logmsg).c_str(), __outf);
     730               0 :     }
     731                 : };
     732                 : 
     733                 : class Reply_HasMethod :
     734                 :     public IPC::Message
     735               0 : {
     736                 : private:
     737                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     738                 :     typedef mozilla::plugins::Variant Variant;
     739                 :     typedef mozilla::ipc::Shmem Shmem;
     740                 :     typedef mozilla::void_t void_t;
     741                 :     typedef mozilla::null_t null_t;
     742                 : 
     743                 : public:
     744                 :     enum {
     745                 :         ID = Reply_HasMethod__ID
     746                 :     };
     747               0 :     Reply_HasMethod() :
     748               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_HasMethod")
     749                 :     {
     750               0 :     }
     751                 : 
     752                 :     void
     753               0 :     Log(
     754                 :             const std::string& __pfx,
     755                 :             FILE* __outf) const
     756                 :     {
     757               0 :         std::string __logmsg;
     758               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     759               0 :         (__logmsg).append(__pfx);
     760               0 :         (__logmsg).append("Reply_HasMethod(");
     761                 : 
     762               0 :         (__logmsg).append("[TODO])\n");
     763               0 :         fputs((__logmsg).c_str(), __outf);
     764               0 :     }
     765                 : };
     766                 : 
     767                 : class Msg_Invoke :
     768                 :     public IPC::Message
     769               0 : {
     770                 : private:
     771                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     772                 :     typedef mozilla::plugins::Variant Variant;
     773                 :     typedef mozilla::ipc::Shmem Shmem;
     774                 :     typedef mozilla::void_t void_t;
     775                 :     typedef mozilla::null_t null_t;
     776                 : 
     777                 : public:
     778                 :     enum {
     779                 :         ID = Msg_Invoke__ID
     780                 :     };
     781               0 :     Msg_Invoke() :
     782               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Invoke")
     783                 :     {
     784               0 :     }
     785                 : 
     786                 :     void
     787               0 :     Log(
     788                 :             const std::string& __pfx,
     789                 :             FILE* __outf) const
     790                 :     {
     791               0 :         std::string __logmsg;
     792               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     793               0 :         (__logmsg).append(__pfx);
     794               0 :         (__logmsg).append("Msg_Invoke(");
     795                 : 
     796               0 :         (__logmsg).append("[TODO])\n");
     797               0 :         fputs((__logmsg).c_str(), __outf);
     798               0 :     }
     799                 : };
     800                 : 
     801                 : class Reply_Invoke :
     802                 :     public IPC::Message
     803               0 : {
     804                 : private:
     805                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     806                 :     typedef mozilla::plugins::Variant Variant;
     807                 :     typedef mozilla::ipc::Shmem Shmem;
     808                 :     typedef mozilla::void_t void_t;
     809                 :     typedef mozilla::null_t null_t;
     810                 : 
     811                 : public:
     812                 :     enum {
     813                 :         ID = Reply_Invoke__ID
     814                 :     };
     815               0 :     Reply_Invoke() :
     816               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_Invoke")
     817                 :     {
     818               0 :     }
     819                 : 
     820                 :     void
     821               0 :     Log(
     822                 :             const std::string& __pfx,
     823                 :             FILE* __outf) const
     824                 :     {
     825               0 :         std::string __logmsg;
     826               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     827               0 :         (__logmsg).append(__pfx);
     828               0 :         (__logmsg).append("Reply_Invoke(");
     829                 : 
     830               0 :         (__logmsg).append("[TODO])\n");
     831               0 :         fputs((__logmsg).c_str(), __outf);
     832               0 :     }
     833                 : };
     834                 : 
     835                 : class Msg_InvokeDefault :
     836                 :     public IPC::Message
     837               0 : {
     838                 : private:
     839                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     840                 :     typedef mozilla::plugins::Variant Variant;
     841                 :     typedef mozilla::ipc::Shmem Shmem;
     842                 :     typedef mozilla::void_t void_t;
     843                 :     typedef mozilla::null_t null_t;
     844                 : 
     845                 : public:
     846                 :     enum {
     847                 :         ID = Msg_InvokeDefault__ID
     848                 :     };
     849               0 :     Msg_InvokeDefault() :
     850               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_InvokeDefault")
     851                 :     {
     852               0 :     }
     853                 : 
     854                 :     void
     855               0 :     Log(
     856                 :             const std::string& __pfx,
     857                 :             FILE* __outf) const
     858                 :     {
     859               0 :         std::string __logmsg;
     860               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     861               0 :         (__logmsg).append(__pfx);
     862               0 :         (__logmsg).append("Msg_InvokeDefault(");
     863                 : 
     864               0 :         (__logmsg).append("[TODO])\n");
     865               0 :         fputs((__logmsg).c_str(), __outf);
     866               0 :     }
     867                 : };
     868                 : 
     869                 : class Reply_InvokeDefault :
     870                 :     public IPC::Message
     871               0 : {
     872                 : private:
     873                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     874                 :     typedef mozilla::plugins::Variant Variant;
     875                 :     typedef mozilla::ipc::Shmem Shmem;
     876                 :     typedef mozilla::void_t void_t;
     877                 :     typedef mozilla::null_t null_t;
     878                 : 
     879                 : public:
     880                 :     enum {
     881                 :         ID = Reply_InvokeDefault__ID
     882                 :     };
     883               0 :     Reply_InvokeDefault() :
     884               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_InvokeDefault")
     885                 :     {
     886               0 :     }
     887                 : 
     888                 :     void
     889               0 :     Log(
     890                 :             const std::string& __pfx,
     891                 :             FILE* __outf) const
     892                 :     {
     893               0 :         std::string __logmsg;
     894               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     895               0 :         (__logmsg).append(__pfx);
     896               0 :         (__logmsg).append("Reply_InvokeDefault(");
     897                 : 
     898               0 :         (__logmsg).append("[TODO])\n");
     899               0 :         fputs((__logmsg).c_str(), __outf);
     900               0 :     }
     901                 : };
     902                 : 
     903                 : class Msg_HasProperty :
     904                 :     public IPC::Message
     905               0 : {
     906                 : private:
     907                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     908                 :     typedef mozilla::plugins::Variant Variant;
     909                 :     typedef mozilla::ipc::Shmem Shmem;
     910                 :     typedef mozilla::void_t void_t;
     911                 :     typedef mozilla::null_t null_t;
     912                 : 
     913                 : public:
     914                 :     enum {
     915                 :         ID = Msg_HasProperty__ID
     916                 :     };
     917               0 :     Msg_HasProperty() :
     918               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_HasProperty")
     919                 :     {
     920               0 :     }
     921                 : 
     922                 :     void
     923               0 :     Log(
     924                 :             const std::string& __pfx,
     925                 :             FILE* __outf) const
     926                 :     {
     927               0 :         std::string __logmsg;
     928               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     929               0 :         (__logmsg).append(__pfx);
     930               0 :         (__logmsg).append("Msg_HasProperty(");
     931                 : 
     932               0 :         (__logmsg).append("[TODO])\n");
     933               0 :         fputs((__logmsg).c_str(), __outf);
     934               0 :     }
     935                 : };
     936                 : 
     937                 : class Reply_HasProperty :
     938                 :     public IPC::Message
     939               0 : {
     940                 : private:
     941                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     942                 :     typedef mozilla::plugins::Variant Variant;
     943                 :     typedef mozilla::ipc::Shmem Shmem;
     944                 :     typedef mozilla::void_t void_t;
     945                 :     typedef mozilla::null_t null_t;
     946                 : 
     947                 : public:
     948                 :     enum {
     949                 :         ID = Reply_HasProperty__ID
     950                 :     };
     951               0 :     Reply_HasProperty() :
     952               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_HasProperty")
     953                 :     {
     954               0 :     }
     955                 : 
     956                 :     void
     957               0 :     Log(
     958                 :             const std::string& __pfx,
     959                 :             FILE* __outf) const
     960                 :     {
     961               0 :         std::string __logmsg;
     962               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     963               0 :         (__logmsg).append(__pfx);
     964               0 :         (__logmsg).append("Reply_HasProperty(");
     965                 : 
     966               0 :         (__logmsg).append("[TODO])\n");
     967               0 :         fputs((__logmsg).c_str(), __outf);
     968               0 :     }
     969                 : };
     970                 : 
     971                 : class Msg_SetProperty :
     972                 :     public IPC::Message
     973               0 : {
     974                 : private:
     975                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     976                 :     typedef mozilla::plugins::Variant Variant;
     977                 :     typedef mozilla::ipc::Shmem Shmem;
     978                 :     typedef mozilla::void_t void_t;
     979                 :     typedef mozilla::null_t null_t;
     980                 : 
     981                 : public:
     982                 :     enum {
     983                 :         ID = Msg_SetProperty__ID
     984                 :     };
     985               0 :     Msg_SetProperty() :
     986               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_SetProperty")
     987                 :     {
     988               0 :     }
     989                 : 
     990                 :     void
     991               0 :     Log(
     992                 :             const std::string& __pfx,
     993                 :             FILE* __outf) const
     994                 :     {
     995               0 :         std::string __logmsg;
     996               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     997               0 :         (__logmsg).append(__pfx);
     998               0 :         (__logmsg).append("Msg_SetProperty(");
     999                 : 
    1000               0 :         (__logmsg).append("[TODO])\n");
    1001               0 :         fputs((__logmsg).c_str(), __outf);
    1002               0 :     }
    1003                 : };
    1004                 : 
    1005                 : class Reply_SetProperty :
    1006                 :     public IPC::Message
    1007               0 : {
    1008                 : private:
    1009                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1010                 :     typedef mozilla::plugins::Variant Variant;
    1011                 :     typedef mozilla::ipc::Shmem Shmem;
    1012                 :     typedef mozilla::void_t void_t;
    1013                 :     typedef mozilla::null_t null_t;
    1014                 : 
    1015                 : public:
    1016                 :     enum {
    1017                 :         ID = Reply_SetProperty__ID
    1018                 :     };
    1019               0 :     Reply_SetProperty() :
    1020               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_SetProperty")
    1021                 :     {
    1022               0 :     }
    1023                 : 
    1024                 :     void
    1025               0 :     Log(
    1026                 :             const std::string& __pfx,
    1027                 :             FILE* __outf) const
    1028                 :     {
    1029               0 :         std::string __logmsg;
    1030               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1031               0 :         (__logmsg).append(__pfx);
    1032               0 :         (__logmsg).append("Reply_SetProperty(");
    1033                 : 
    1034               0 :         (__logmsg).append("[TODO])\n");
    1035               0 :         fputs((__logmsg).c_str(), __outf);
    1036               0 :     }
    1037                 : };
    1038                 : 
    1039                 : class Msg_RemoveProperty :
    1040                 :     public IPC::Message
    1041               0 : {
    1042                 : private:
    1043                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1044                 :     typedef mozilla::plugins::Variant Variant;
    1045                 :     typedef mozilla::ipc::Shmem Shmem;
    1046                 :     typedef mozilla::void_t void_t;
    1047                 :     typedef mozilla::null_t null_t;
    1048                 : 
    1049                 : public:
    1050                 :     enum {
    1051                 :         ID = Msg_RemoveProperty__ID
    1052                 :     };
    1053               0 :     Msg_RemoveProperty() :
    1054               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_RemoveProperty")
    1055                 :     {
    1056               0 :     }
    1057                 : 
    1058                 :     void
    1059               0 :     Log(
    1060                 :             const std::string& __pfx,
    1061                 :             FILE* __outf) const
    1062                 :     {
    1063               0 :         std::string __logmsg;
    1064               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1065               0 :         (__logmsg).append(__pfx);
    1066               0 :         (__logmsg).append("Msg_RemoveProperty(");
    1067                 : 
    1068               0 :         (__logmsg).append("[TODO])\n");
    1069               0 :         fputs((__logmsg).c_str(), __outf);
    1070               0 :     }
    1071                 : };
    1072                 : 
    1073                 : class Reply_RemoveProperty :
    1074                 :     public IPC::Message
    1075               0 : {
    1076                 : private:
    1077                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1078                 :     typedef mozilla::plugins::Variant Variant;
    1079                 :     typedef mozilla::ipc::Shmem Shmem;
    1080                 :     typedef mozilla::void_t void_t;
    1081                 :     typedef mozilla::null_t null_t;
    1082                 : 
    1083                 : public:
    1084                 :     enum {
    1085                 :         ID = Reply_RemoveProperty__ID
    1086                 :     };
    1087               0 :     Reply_RemoveProperty() :
    1088               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_RemoveProperty")
    1089                 :     {
    1090               0 :     }
    1091                 : 
    1092                 :     void
    1093               0 :     Log(
    1094                 :             const std::string& __pfx,
    1095                 :             FILE* __outf) const
    1096                 :     {
    1097               0 :         std::string __logmsg;
    1098               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1099               0 :         (__logmsg).append(__pfx);
    1100               0 :         (__logmsg).append("Reply_RemoveProperty(");
    1101                 : 
    1102               0 :         (__logmsg).append("[TODO])\n");
    1103               0 :         fputs((__logmsg).c_str(), __outf);
    1104               0 :     }
    1105                 : };
    1106                 : 
    1107                 : class Msg_Enumerate :
    1108                 :     public IPC::Message
    1109               0 : {
    1110                 : private:
    1111                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1112                 :     typedef mozilla::plugins::Variant Variant;
    1113                 :     typedef mozilla::ipc::Shmem Shmem;
    1114                 :     typedef mozilla::void_t void_t;
    1115                 :     typedef mozilla::null_t null_t;
    1116                 : 
    1117                 : public:
    1118                 :     enum {
    1119                 :         ID = Msg_Enumerate__ID
    1120                 :     };
    1121               0 :     Msg_Enumerate() :
    1122               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Enumerate")
    1123                 :     {
    1124               0 :     }
    1125                 : 
    1126                 :     void
    1127               0 :     Log(
    1128                 :             const std::string& __pfx,
    1129                 :             FILE* __outf) const
    1130                 :     {
    1131               0 :         std::string __logmsg;
    1132               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1133               0 :         (__logmsg).append(__pfx);
    1134               0 :         (__logmsg).append("Msg_Enumerate(");
    1135                 : 
    1136               0 :         (__logmsg).append("[TODO])\n");
    1137               0 :         fputs((__logmsg).c_str(), __outf);
    1138               0 :     }
    1139                 : };
    1140                 : 
    1141                 : class Reply_Enumerate :
    1142                 :     public IPC::Message
    1143               0 : {
    1144                 : private:
    1145                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1146                 :     typedef mozilla::plugins::Variant Variant;
    1147                 :     typedef mozilla::ipc::Shmem Shmem;
    1148                 :     typedef mozilla::void_t void_t;
    1149                 :     typedef mozilla::null_t null_t;
    1150                 : 
    1151                 : public:
    1152                 :     enum {
    1153                 :         ID = Reply_Enumerate__ID
    1154                 :     };
    1155               0 :     Reply_Enumerate() :
    1156               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_Enumerate")
    1157                 :     {
    1158               0 :     }
    1159                 : 
    1160                 :     void
    1161               0 :     Log(
    1162                 :             const std::string& __pfx,
    1163                 :             FILE* __outf) const
    1164                 :     {
    1165               0 :         std::string __logmsg;
    1166               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1167               0 :         (__logmsg).append(__pfx);
    1168               0 :         (__logmsg).append("Reply_Enumerate(");
    1169                 : 
    1170               0 :         (__logmsg).append("[TODO])\n");
    1171               0 :         fputs((__logmsg).c_str(), __outf);
    1172               0 :     }
    1173                 : };
    1174                 : 
    1175                 : class Msg_Construct :
    1176                 :     public IPC::Message
    1177               0 : {
    1178                 : private:
    1179                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1180                 :     typedef mozilla::plugins::Variant Variant;
    1181                 :     typedef mozilla::ipc::Shmem Shmem;
    1182                 :     typedef mozilla::void_t void_t;
    1183                 :     typedef mozilla::null_t null_t;
    1184                 : 
    1185                 : public:
    1186                 :     enum {
    1187                 :         ID = Msg_Construct__ID
    1188                 :     };
    1189               0 :     Msg_Construct() :
    1190               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Construct")
    1191                 :     {
    1192               0 :     }
    1193                 : 
    1194                 :     void
    1195               0 :     Log(
    1196                 :             const std::string& __pfx,
    1197                 :             FILE* __outf) const
    1198                 :     {
    1199               0 :         std::string __logmsg;
    1200               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1201               0 :         (__logmsg).append(__pfx);
    1202               0 :         (__logmsg).append("Msg_Construct(");
    1203                 : 
    1204               0 :         (__logmsg).append("[TODO])\n");
    1205               0 :         fputs((__logmsg).c_str(), __outf);
    1206               0 :     }
    1207                 : };
    1208                 : 
    1209                 : class Reply_Construct :
    1210                 :     public IPC::Message
    1211               0 : {
    1212                 : private:
    1213                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1214                 :     typedef mozilla::plugins::Variant Variant;
    1215                 :     typedef mozilla::ipc::Shmem Shmem;
    1216                 :     typedef mozilla::void_t void_t;
    1217                 :     typedef mozilla::null_t null_t;
    1218                 : 
    1219                 : public:
    1220                 :     enum {
    1221                 :         ID = Reply_Construct__ID
    1222                 :     };
    1223               0 :     Reply_Construct() :
    1224               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_Construct")
    1225                 :     {
    1226               0 :     }
    1227                 : 
    1228                 :     void
    1229               0 :     Log(
    1230                 :             const std::string& __pfx,
    1231                 :             FILE* __outf) const
    1232                 :     {
    1233               0 :         std::string __logmsg;
    1234               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1235               0 :         (__logmsg).append(__pfx);
    1236               0 :         (__logmsg).append("Reply_Construct(");
    1237                 : 
    1238               0 :         (__logmsg).append("[TODO])\n");
    1239               0 :         fputs((__logmsg).c_str(), __outf);
    1240               0 :     }
    1241                 : };
    1242                 : 
    1243                 : class Msg_Protect :
    1244                 :     public IPC::Message
    1245               0 : {
    1246                 : private:
    1247                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1248                 :     typedef mozilla::plugins::Variant Variant;
    1249                 :     typedef mozilla::ipc::Shmem Shmem;
    1250                 :     typedef mozilla::void_t void_t;
    1251                 :     typedef mozilla::null_t null_t;
    1252                 : 
    1253                 : public:
    1254                 :     enum {
    1255                 :         ID = Msg_Protect__ID
    1256                 :     };
    1257               0 :     Msg_Protect() :
    1258               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Protect")
    1259                 :     {
    1260               0 :     }
    1261                 : 
    1262                 :     void
    1263               0 :     Log(
    1264                 :             const std::string& __pfx,
    1265                 :             FILE* __outf) const
    1266                 :     {
    1267               0 :         std::string __logmsg;
    1268               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1269               0 :         (__logmsg).append(__pfx);
    1270               0 :         (__logmsg).append("Msg_Protect(");
    1271                 : 
    1272               0 :         (__logmsg).append("[TODO])\n");
    1273               0 :         fputs((__logmsg).c_str(), __outf);
    1274               0 :     }
    1275                 : };
    1276                 : 
    1277                 : class Msg_Unprotect :
    1278                 :     public IPC::Message
    1279               0 : {
    1280                 : private:
    1281                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1282                 :     typedef mozilla::plugins::Variant Variant;
    1283                 :     typedef mozilla::ipc::Shmem Shmem;
    1284                 :     typedef mozilla::void_t void_t;
    1285                 :     typedef mozilla::null_t null_t;
    1286                 : 
    1287                 : public:
    1288                 :     enum {
    1289                 :         ID = Msg_Unprotect__ID
    1290                 :     };
    1291               0 :     Msg_Unprotect() :
    1292               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_Unprotect")
    1293                 :     {
    1294               0 :     }
    1295                 : 
    1296                 :     void
    1297               0 :     Log(
    1298                 :             const std::string& __pfx,
    1299                 :             FILE* __outf) const
    1300                 :     {
    1301               0 :         std::string __logmsg;
    1302               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1303               0 :         (__logmsg).append(__pfx);
    1304               0 :         (__logmsg).append("Msg_Unprotect(");
    1305                 : 
    1306               0 :         (__logmsg).append("[TODO])\n");
    1307               0 :         fputs((__logmsg).c_str(), __outf);
    1308               0 :     }
    1309                 : };
    1310                 : 
    1311                 : class Msg_GetParentProperty :
    1312                 :     public IPC::Message
    1313               0 : {
    1314                 : private:
    1315                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1316                 :     typedef mozilla::plugins::Variant Variant;
    1317                 :     typedef mozilla::ipc::Shmem Shmem;
    1318                 :     typedef mozilla::void_t void_t;
    1319                 :     typedef mozilla::null_t null_t;
    1320                 : 
    1321                 : public:
    1322                 :     enum {
    1323                 :         ID = Msg_GetParentProperty__ID
    1324                 :     };
    1325               0 :     Msg_GetParentProperty() :
    1326               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_GetParentProperty")
    1327                 :     {
    1328               0 :     }
    1329                 : 
    1330                 :     void
    1331               0 :     Log(
    1332                 :             const std::string& __pfx,
    1333                 :             FILE* __outf) const
    1334                 :     {
    1335               0 :         std::string __logmsg;
    1336               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1337               0 :         (__logmsg).append(__pfx);
    1338               0 :         (__logmsg).append("Msg_GetParentProperty(");
    1339                 : 
    1340               0 :         (__logmsg).append("[TODO])\n");
    1341               0 :         fputs((__logmsg).c_str(), __outf);
    1342               0 :     }
    1343                 : };
    1344                 : 
    1345                 : class Reply_GetParentProperty :
    1346                 :     public IPC::Message
    1347               0 : {
    1348                 : private:
    1349                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1350                 :     typedef mozilla::plugins::Variant Variant;
    1351                 :     typedef mozilla::ipc::Shmem Shmem;
    1352                 :     typedef mozilla::void_t void_t;
    1353                 :     typedef mozilla::null_t null_t;
    1354                 : 
    1355                 : public:
    1356                 :     enum {
    1357                 :         ID = Reply_GetParentProperty__ID
    1358                 :     };
    1359               0 :     Reply_GetParentProperty() :
    1360               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_GetParentProperty")
    1361                 :     {
    1362               0 :     }
    1363                 : 
    1364                 :     void
    1365               0 :     Log(
    1366                 :             const std::string& __pfx,
    1367                 :             FILE* __outf) const
    1368                 :     {
    1369               0 :         std::string __logmsg;
    1370               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1371               0 :         (__logmsg).append(__pfx);
    1372               0 :         (__logmsg).append("Reply_GetParentProperty(");
    1373                 : 
    1374               0 :         (__logmsg).append("[TODO])\n");
    1375               0 :         fputs((__logmsg).c_str(), __outf);
    1376               0 :     }
    1377                 : };
    1378                 : 
    1379                 : class Msg_GetChildProperty :
    1380                 :     public IPC::Message
    1381               0 : {
    1382                 : private:
    1383                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1384                 :     typedef mozilla::plugins::Variant Variant;
    1385                 :     typedef mozilla::ipc::Shmem Shmem;
    1386                 :     typedef mozilla::void_t void_t;
    1387                 :     typedef mozilla::null_t null_t;
    1388                 : 
    1389                 : public:
    1390                 :     enum {
    1391                 :         ID = Msg_GetChildProperty__ID
    1392                 :     };
    1393               0 :     Msg_GetChildProperty() :
    1394               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Msg_GetChildProperty")
    1395                 :     {
    1396               0 :     }
    1397                 : 
    1398                 :     void
    1399               0 :     Log(
    1400                 :             const std::string& __pfx,
    1401                 :             FILE* __outf) const
    1402                 :     {
    1403               0 :         std::string __logmsg;
    1404               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1405               0 :         (__logmsg).append(__pfx);
    1406               0 :         (__logmsg).append("Msg_GetChildProperty(");
    1407                 : 
    1408               0 :         (__logmsg).append("[TODO])\n");
    1409               0 :         fputs((__logmsg).c_str(), __outf);
    1410               0 :     }
    1411                 : };
    1412                 : 
    1413                 : class Reply_GetChildProperty :
    1414                 :     public IPC::Message
    1415               0 : {
    1416                 : private:
    1417                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1418                 :     typedef mozilla::plugins::Variant Variant;
    1419                 :     typedef mozilla::ipc::Shmem Shmem;
    1420                 :     typedef mozilla::void_t void_t;
    1421                 :     typedef mozilla::null_t null_t;
    1422                 : 
    1423                 : public:
    1424                 :     enum {
    1425                 :         ID = Reply_GetChildProperty__ID
    1426                 :     };
    1427               0 :     Reply_GetChildProperty() :
    1428               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PPluginScriptableObject::Reply_GetChildProperty")
    1429                 :     {
    1430               0 :     }
    1431                 : 
    1432                 :     void
    1433               0 :     Log(
    1434                 :             const std::string& __pfx,
    1435                 :             FILE* __outf) const
    1436                 :     {
    1437               0 :         std::string __logmsg;
    1438               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1439               0 :         (__logmsg).append(__pfx);
    1440               0 :         (__logmsg).append("Reply_GetChildProperty(");
    1441                 : 
    1442               0 :         (__logmsg).append("[TODO])\n");
    1443               0 :         fputs((__logmsg).c_str(), __outf);
    1444               0 :     }
    1445                 : };
    1446                 : 
    1447                 : 
    1448                 : 
    1449                 : } // namespace PPluginScriptableObject
    1450                 : } // namespace plugins
    1451                 : } // namespace mozilla
    1452                 : 
    1453                 : #endif // ifndef PPluginScriptableObject_h

Generated by: LCOV version 1.7